clawvault 3.2.1 → 3.4.0

package/dist/plugin/index.js

@@ -1,4264 +0,0 @@
-import {
-  __commonJS,
-  __toESM
-} from "../chunk-U67V476Y.js";
-
-// node_modules/@sinclair/typebox/typebox.js
-var require_typebox = __commonJS({
-  "node_modules/@sinclair/typebox/typebox.js"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
-    exports.Modifier = /* @__PURE__ */ Symbol.for("TypeBox.Modifier");
-    exports.Hint = /* @__PURE__ */ Symbol.for("TypeBox.Hint");
-    exports.Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
-    exports.PatternBoolean = "(true|false)";
-    exports.PatternNumber = "(0|[1-9][0-9]*)";
-    exports.PatternString = "(.*)";
-    exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
-    exports.PatternNumberExact = `^${exports.PatternNumber}$`;
-    exports.PatternStringExact = `^${exports.PatternString}$`;
-    var TypeRegistry;
-    (function(TypeRegistry2) {
-      const map = /* @__PURE__ */ new Map();
-      function Entries() {
-        return new Map(map);
-      }
-      TypeRegistry2.Entries = Entries;
-      function Clear() {
-        return map.clear();
-      }
-      TypeRegistry2.Clear = Clear;
-      function Has(kind) {
-        return map.has(kind);
-      }
-      TypeRegistry2.Has = Has;
-      function Set2(kind, func) {
-        map.set(kind, func);
-      }
-      TypeRegistry2.Set = Set2;
-      function Get(kind) {
-        return map.get(kind);
-      }
-      TypeRegistry2.Get = Get;
-    })(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
-    var FormatRegistry;
-    (function(FormatRegistry2) {
-      const map = /* @__PURE__ */ new Map();
-      function Entries() {
-        return new Map(map);
-      }
-      FormatRegistry2.Entries = Entries;
-      function Clear() {
-        return map.clear();
-      }
-      FormatRegistry2.Clear = Clear;
-      function Has(format) {
-        return map.has(format);
-      }
-      FormatRegistry2.Has = Has;
-      function Set2(format, func) {
-        map.set(format, func);
-      }
-      FormatRegistry2.Set = Set2;
-      function Get(format) {
-        return map.get(format);
-      }
-      FormatRegistry2.Get = Get;
-    })(FormatRegistry = exports.FormatRegistry || (exports.FormatRegistry = {}));
-    var TypeGuardUnknownTypeError = class extends Error {
-      constructor(schema) {
-        super("TypeGuard: Unknown type");
-        this.schema = schema;
-      }
-    };
-    exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
-    var TypeGuard;
-    (function(TypeGuard2) {
-      function IsObject(value) {
-        return typeof value === "object" && value !== null && !Array.isArray(value);
-      }
-      function IsArray(value) {
-        return typeof value === "object" && value !== null && Array.isArray(value);
-      }
-      function IsPattern(value) {
-        try {
-          new RegExp(value);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      function IsControlCharacterFree(value) {
-        if (typeof value !== "string")
-          return false;
-        for (let i = 0; i < value.length; i++) {
-          const code = value.charCodeAt(i);
-          if (code >= 7 && code <= 13 || code === 27 || code === 127) {
-            return false;
-          }
-        }
-        return true;
-      }
-      function IsBigInt(value) {
-        return typeof value === "bigint";
-      }
-      function IsString(value) {
-        return typeof value === "string";
-      }
-      function IsNumber(value) {
-        return typeof value === "number" && globalThis.Number.isFinite(value);
-      }
-      function IsBoolean(value) {
-        return typeof value === "boolean";
-      }
-      function IsOptionalBigInt(value) {
-        return value === void 0 || value !== void 0 && IsBigInt(value);
-      }
-      function IsOptionalNumber(value) {
-        return value === void 0 || value !== void 0 && IsNumber(value);
-      }
-      function IsOptionalBoolean(value) {
-        return value === void 0 || value !== void 0 && IsBoolean(value);
-      }
-      function IsOptionalString(value) {
-        return value === void 0 || value !== void 0 && IsString(value);
-      }
-      function IsOptionalPattern(value) {
-        return value === void 0 || value !== void 0 && IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
-      }
-      function IsOptionalFormat(value) {
-        return value === void 0 || value !== void 0 && IsString(value) && IsControlCharacterFree(value);
-      }
-      function IsOptionalSchema(value) {
-        return value === void 0 || TSchema(value);
-      }
-      function TAny(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Any" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TAny = TAny;
-      function TArray(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Array" && schema.type === "array" && IsOptionalString(schema.$id) && TSchema(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems);
-      }
-      TypeGuard2.TArray = TArray;
-      function TBigInt(schema) {
-        return TKind(schema) && schema[exports.Kind] === "BigInt" && schema.type === "null" && schema.typeOf === "BigInt" && IsOptionalString(schema.$id) && IsOptionalBigInt(schema.multipleOf) && IsOptionalBigInt(schema.minimum) && IsOptionalBigInt(schema.maximum) && IsOptionalBigInt(schema.exclusiveMinimum) && IsOptionalBigInt(schema.exclusiveMaximum);
-      }
-      TypeGuard2.TBigInt = TBigInt;
-      function TBoolean(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Boolean" && schema.type === "boolean" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TBoolean = TBoolean;
-      function TConstructor(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Constructor" && schema.type === "object" && schema.instanceOf === "Constructor" && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
-          return false;
-        }
-        for (const parameter of schema.parameters) {
-          if (!TSchema(parameter))
-            return false;
-        }
-        return true;
-      }
-      TypeGuard2.TConstructor = TConstructor;
-      function TDate(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Date" && schema.type === "object" && schema.instanceOf === "Date" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minimumTimestamp) && IsOptionalNumber(schema.maximumTimestamp) && IsOptionalNumber(schema.exclusiveMinimumTimestamp) && IsOptionalNumber(schema.exclusiveMaximumTimestamp);
-      }
-      TypeGuard2.TDate = TDate;
-      function TFunction(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Function" && schema.type === "object" && schema.instanceOf === "Function" && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
-          return false;
-        }
-        for (const parameter of schema.parameters) {
-          if (!TSchema(parameter))
-            return false;
-        }
-        return true;
-      }
-      TypeGuard2.TFunction = TFunction;
-      function TInteger(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Integer" && schema.type === "integer" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.multipleOf) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.exclusiveMaximum);
-      }
-      TypeGuard2.TInteger = TInteger;
-      function TIntersect(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Intersect" && IsArray(schema.allOf) && IsOptionalString(schema.type) && (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) && IsOptionalString(schema.$id))) {
-          return false;
-        }
-        if ("type" in schema && schema.type !== "object") {
-          return false;
-        }
-        for (const inner of schema.allOf) {
-          if (!TSchema(inner))
-            return false;
-        }
-        return true;
-      }
-      TypeGuard2.TIntersect = TIntersect;
-      function TKind(schema) {
-        return IsObject(schema) && exports.Kind in schema && typeof schema[exports.Kind] === "string";
-      }
-      TypeGuard2.TKind = TKind;
-      function TLiteral(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Literal" && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const) || IsBigInt(schema.const));
-      }
-      TypeGuard2.TLiteral = TLiteral;
-      function TNever(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Never" && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0;
-      }
-      TypeGuard2.TNever = TNever;
-      function TNot(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Not" && IsArray(schema.allOf) && schema.allOf.length === 2 && IsObject(schema.allOf[0]) && TSchema(schema.allOf[0].not) && TSchema(schema.allOf[1]);
-      }
-      TypeGuard2.TNot = TNot;
-      function TNull(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Null" && schema.type === "null" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TNull = TNull;
-      function TNumber(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Number" && schema.type === "number" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.multipleOf) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.exclusiveMaximum);
-      }
-      TypeGuard2.TNumber = TNumber;
-      function TObject(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Object" && schema.type === "object" && IsOptionalString(schema.$id) && IsObject(schema.properties) && (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) && IsOptionalNumber(schema.minProperties) && IsOptionalNumber(schema.maxProperties))) {
-          return false;
-        }
-        for (const [key, value] of Object.entries(schema.properties)) {
-          if (!IsControlCharacterFree(key))
-            return false;
-          if (!TSchema(value))
-            return false;
-        }
-        return true;
-      }
-      TypeGuard2.TObject = TObject;
-      function TPromise(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Promise" && schema.type === "object" && schema.instanceOf === "Promise" && IsOptionalString(schema.$id) && TSchema(schema.item);
-      }
-      TypeGuard2.TPromise = TPromise;
-      function TRecord(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Record" && schema.type === "object" && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
-          return false;
-        }
-        const keys = Object.keys(schema.patternProperties);
-        if (keys.length !== 1) {
-          return false;
-        }
-        if (!IsPattern(keys[0])) {
-          return false;
-        }
-        if (!TSchema(schema.patternProperties[keys[0]])) {
-          return false;
-        }
-        return true;
-      }
-      TypeGuard2.TRecord = TRecord;
-      function TRef(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Ref" && IsOptionalString(schema.$id) && IsString(schema.$ref);
-      }
-      TypeGuard2.TRef = TRef;
-      function TString(schema) {
-        return TKind(schema) && schema[exports.Kind] === "String" && schema.type === "string" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format);
-      }
-      TypeGuard2.TString = TString;
-      function TSymbol(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Symbol" && schema.type === "null" && schema.typeOf === "Symbol" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TSymbol = TSymbol;
-      function TTemplateLiteral(schema) {
-        return TKind(schema) && schema[exports.Kind] === "TemplateLiteral" && schema.type === "string" && IsString(schema.pattern) && schema.pattern[0] === "^" && schema.pattern[schema.pattern.length - 1] === "$";
-      }
-      TypeGuard2.TTemplateLiteral = TTemplateLiteral;
-      function TThis(schema) {
-        return TKind(schema) && schema[exports.Kind] === "This" && IsOptionalString(schema.$id) && IsString(schema.$ref);
-      }
-      TypeGuard2.TThis = TThis;
-      function TTuple(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Tuple" && schema.type === "array" && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
-          return false;
-        }
-        if (schema.items === void 0 && schema.additionalItems === void 0 && schema.minItems === 0) {
-          return true;
-        }
-        if (!IsArray(schema.items)) {
-          return false;
-        }
-        for (const inner of schema.items) {
-          if (!TSchema(inner))
-            return false;
-        }
-        return true;
-      }
-      TypeGuard2.TTuple = TTuple;
-      function TUndefined(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Undefined" && schema.type === "null" && schema.typeOf === "Undefined" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TUndefined = TUndefined;
-      function TUnion(schema) {
-        if (!(TKind(schema) && schema[exports.Kind] === "Union" && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
-          return false;
-        }
-        for (const inner of schema.anyOf) {
-          if (!TSchema(inner))
-            return false;
-        }
-        return true;
-      }
-      TypeGuard2.TUnion = TUnion;
-      function TUnionLiteral(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema2) => TLiteral(schema2) && typeof schema2.const === "string");
-      }
-      TypeGuard2.TUnionLiteral = TUnionLiteral;
-      function TUint8Array(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Uint8Array" && schema.type === "object" && IsOptionalString(schema.$id) && schema.instanceOf === "Uint8Array" && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
-      }
-      TypeGuard2.TUint8Array = TUint8Array;
-      function TUnknown(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Unknown" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TUnknown = TUnknown;
-      function TUnsafe(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Unsafe";
-      }
-      TypeGuard2.TUnsafe = TUnsafe;
-      function TVoid(schema) {
-        return TKind(schema) && schema[exports.Kind] === "Void" && schema.type === "null" && schema.typeOf === "Void" && IsOptionalString(schema.$id);
-      }
-      TypeGuard2.TVoid = TVoid;
-      function TReadonlyOptional(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === "ReadonlyOptional";
-      }
-      TypeGuard2.TReadonlyOptional = TReadonlyOptional;
-      function TReadonly(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === "Readonly";
-      }
-      TypeGuard2.TReadonly = TReadonly;
-      function TOptional(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === "Optional";
-      }
-      TypeGuard2.TOptional = TOptional;
-      function TSchema(schema) {
-        return typeof schema === "object" && (TAny(schema) || TArray(schema) || TBoolean(schema) || TBigInt(schema) || TConstructor(schema) || TDate(schema) || TFunction(schema) || TInteger(schema) || TIntersect(schema) || TLiteral(schema) || TNever(schema) || TNot(schema) || TNull(schema) || TNumber(schema) || TObject(schema) || TPromise(schema) || TRecord(schema) || TRef(schema) || TString(schema) || TSymbol(schema) || TTemplateLiteral(schema) || TThis(schema) || TTuple(schema) || TUndefined(schema) || TUnion(schema) || TUint8Array(schema) || TUnknown(schema) || TUnsafe(schema) || TVoid(schema) || TKind(schema) && TypeRegistry.Has(schema[exports.Kind]));
-      }
-      TypeGuard2.TSchema = TSchema;
-    })(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));
-    var ExtendsUndefined;
-    (function(ExtendsUndefined2) {
-      function Check(schema) {
-        if (schema[exports.Kind] === "Undefined")
-          return true;
-        if (schema[exports.Kind] === "Union") {
-          const union = schema;
-          return union.anyOf.some((schema2) => Check(schema2));
-        }
-        return false;
-      }
-      ExtendsUndefined2.Check = Check;
-    })(ExtendsUndefined = exports.ExtendsUndefined || (exports.ExtendsUndefined = {}));
-    var TypeExtendsResult;
-    (function(TypeExtendsResult2) {
-      TypeExtendsResult2[TypeExtendsResult2["Union"] = 0] = "Union";
-      TypeExtendsResult2[TypeExtendsResult2["True"] = 1] = "True";
-      TypeExtendsResult2[TypeExtendsResult2["False"] = 2] = "False";
-    })(TypeExtendsResult = exports.TypeExtendsResult || (exports.TypeExtendsResult = {}));
-    var TypeExtends;
-    (function(TypeExtends2) {
-      function IntoBooleanResult(result) {
-        return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True;
-      }
-      function AnyRight(left, right) {
-        return TypeExtendsResult.True;
-      }
-      function Any(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TUnion(right))
-          return TypeExtendsResult.Union;
-        if (TypeGuard.TUnknown(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TAny(right))
-          return TypeExtendsResult.True;
-        return TypeExtendsResult.Union;
-      }
-      function ArrayRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-          return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-          return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-          return TypeExtendsResult.True;
-        return TypeExtendsResult.False;
-      }
-      function Array2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
-          return TypeExtendsResult.True;
-        if (!TypeGuard.TArray(right))
-          return TypeExtendsResult.False;
-        return IntoBooleanResult(Visit(left.items, right.items));
-      }
-      function BigInt(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function BooleanRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === "boolean")
-          return TypeExtendsResult.True;
-        return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Boolean(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Constructor(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (!TypeGuard.TConstructor(right))
-          return TypeExtendsResult.False;
-        if (left.parameters.length > right.parameters.length)
-          return TypeExtendsResult.False;
-        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-          return TypeExtendsResult.False;
-        }
-        return IntoBooleanResult(Visit(left.returns, right.returns));
-      }
-      function Date2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Function(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (!TypeGuard.TFunction(right))
-          return TypeExtendsResult.False;
-        if (left.parameters.length > right.parameters.length)
-          return TypeExtendsResult.False;
-        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-          return TypeExtendsResult.False;
-        }
-        return IntoBooleanResult(Visit(left.returns, right.returns));
-      }
-      function IntegerRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === "number")
-          return TypeExtendsResult.True;
-        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Integer(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function IntersectRight(left, right) {
-        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Intersect(left, right) {
-        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function IsLiteralString(schema) {
-        return typeof schema.const === "string";
-      }
-      function IsLiteralNumber(schema) {
-        return typeof schema.const === "number";
-      }
-      function IsLiteralBoolean(schema) {
-        return typeof schema.const === "boolean";
-      }
-      function Literal(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        if (TypeGuard.TString(right))
-          return StringRight(left, right);
-        if (TypeGuard.TNumber(right))
-          return NumberRight(left, right);
-        if (TypeGuard.TInteger(right))
-          return IntegerRight(left, right);
-        if (TypeGuard.TBoolean(right))
-          return BooleanRight(left, right);
-        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function NeverRight(left, right) {
-        return TypeExtendsResult.False;
-      }
-      function Never(left, right) {
-        return TypeExtendsResult.True;
-      }
-      function Null(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function NumberRight(left, right) {
-        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left))
-          return TypeExtendsResult.True;
-        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Number2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function IsObjectPropertyCount(schema, count) {
-        return globalThis.Object.keys(schema.properties).length === count;
-      }
-      function IsObjectStringLike(schema) {
-        return IsObjectArrayLike(schema);
-      }
-      function IsObjectSymbolLike(schema) {
-        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (TypeGuard.TString(schema.properties.description.anyOf[0]) && TypeGuard.TUndefined(schema.properties.description.anyOf[1]) || TypeGuard.TString(schema.properties.description.anyOf[1]) && TypeGuard.TUndefined(schema.properties.description.anyOf[0]));
-      }
-      function IsObjectNumberLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-      }
-      function IsObjectBooleanLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-      }
-      function IsObjectBigIntLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-      }
-      function IsObjectDateLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-      }
-      function IsObjectUint8ArrayLike(schema) {
-        return IsObjectArrayLike(schema);
-      }
-      function IsObjectFunctionLike(schema) {
-        const length = exports.Type.Number();
-        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
-      }
-      function IsObjectConstructorLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-      }
-      function IsObjectArrayLike(schema) {
-        const length = exports.Type.Number();
-        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
-      }
-      function IsObjectPromiseLike(schema) {
-        const then = exports.Type.Function([exports.Type.Any()], exports.Type.Any());
-        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === TypeExtendsResult.True;
-      }
-      function Property(left, right) {
-        if (Visit(left, right) === TypeExtendsResult.False)
-          return TypeExtendsResult.False;
-        if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right))
-          return TypeExtendsResult.False;
-        return TypeExtendsResult.True;
-      }
-      function ObjectRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-          return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-          return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TString(left) && IsObjectStringLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TNumber(left) && IsObjectNumberLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TInteger(left) && IsObjectNumberLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TDate(left) && IsObjectDateLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
-          return right[exports.Hint] === "Record" ? TypeExtendsResult.True : TypeExtendsResult.False;
-        }
-        if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
-          return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
-        }
-        return TypeExtendsResult.False;
-      }
-      function Object2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        if (!TypeGuard.TObject(right))
-          return TypeExtendsResult.False;
-        for (const key of globalThis.Object.keys(right.properties)) {
-          if (!(key in left.properties))
-            return TypeExtendsResult.False;
-          if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
-            return TypeExtendsResult.False;
-          }
-        }
-        return TypeExtendsResult.True;
-      }
-      function Promise2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectPromiseLike(right))
-          return TypeExtendsResult.True;
-        if (!TypeGuard.TPromise(right))
-          return TypeExtendsResult.False;
-        return IntoBooleanResult(Visit(left.item, right.item));
-      }
-      function RecordKey(schema) {
-        if (exports.PatternNumberExact in schema.patternProperties)
-          return exports.Type.Number();
-        if (exports.PatternStringExact in schema.patternProperties)
-          return exports.Type.String();
-        throw Error("TypeExtends: Cannot get record key");
-      }
-      function RecordValue(schema) {
-        if (exports.PatternNumberExact in schema.patternProperties)
-          return schema.patternProperties[exports.PatternNumberExact];
-        if (exports.PatternStringExact in schema.patternProperties)
-          return schema.patternProperties[exports.PatternStringExact];
-        throw Error("TypeExtends: Cannot get record value");
-      }
-      function RecordRight(left, right) {
-        const Key = RecordKey(right);
-        const Value = RecordValue(right);
-        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True)
-          return TypeExtendsResult.True;
-        if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key))
-          return Visit(left, Value);
-        if (TypeGuard.TString(left) && TypeGuard.TNumber(Key))
-          return Visit(left, Value);
-        if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key))
-          return Visit(left, Value);
-        if (TypeGuard.TObject(left)) {
-          for (const key of globalThis.Object.keys(left.properties)) {
-            if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
-              return TypeExtendsResult.False;
-            }
-          }
-          return TypeExtendsResult.True;
-        }
-        return TypeExtendsResult.False;
-      }
-      function Record(left, right) {
-        const Value = RecordValue(left);
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (!TypeGuard.TRecord(right))
-          return TypeExtendsResult.False;
-        return Visit(Value, RecordValue(right));
-      }
-      function StringRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === "string")
-          return TypeExtendsResult.True;
-        return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function String2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Symbol2(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function TupleRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-          return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-          return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-          return TypeExtendsResult.True;
-        return TypeExtendsResult.False;
-      }
-      function IsArrayOfTuple(left, right) {
-        return TypeGuard.TArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
-      }
-      function Tuple(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
-          return TypeExtendsResult.True;
-        if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right))
-          return TypeExtendsResult.True;
-        if (!TypeGuard.TTuple(right))
-          return TypeExtendsResult.False;
-        if (left.items === void 0 && right.items !== void 0 || left.items !== void 0 && right.items === void 0)
-          return TypeExtendsResult.False;
-        if (left.items === void 0 && right.items === void 0)
-          return TypeExtendsResult.True;
-        return left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Uint8Array(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Undefined(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-          return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-          return RecordRight(left, right);
-        if (TypeGuard.TVoid(right))
-          return VoidRight(left, right);
-        return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function UnionRight(left, right) {
-        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Union(left, right) {
-        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function UnknownRight(left, right) {
-        return TypeExtendsResult.True;
-      }
-      function Unknown(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TString(right))
-          return StringRight(left, right);
-        if (TypeGuard.TNumber(right))
-          return NumberRight(left, right);
-        if (TypeGuard.TInteger(right))
-          return IntegerRight(left, right);
-        if (TypeGuard.TBoolean(right))
-          return BooleanRight(left, right);
-        if (TypeGuard.TArray(right))
-          return ArrayRight(left, right);
-        if (TypeGuard.TTuple(right))
-          return TupleRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function VoidRight(left, right) {
-        if (TypeGuard.TUndefined(left))
-          return TypeExtendsResult.True;
-        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Void(left, right) {
-        if (TypeGuard.TIntersect(right))
-          return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-          return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-          return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-          return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-          return ObjectRight(left, right);
-        return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-      }
-      function Visit(left, right) {
-        if (TypeGuard.TTemplateLiteral(left))
-          return Visit(TemplateLiteralResolver.Resolve(left), right);
-        if (TypeGuard.TTemplateLiteral(right))
-          return Visit(left, TemplateLiteralResolver.Resolve(right));
-        if (TypeGuard.TAny(left))
-          return Any(left, right);
-        if (TypeGuard.TArray(left))
-          return Array2(left, right);
-        if (TypeGuard.TBigInt(left))
-          return BigInt(left, right);
-        if (TypeGuard.TBoolean(left))
-          return Boolean(left, right);
-        if (TypeGuard.TConstructor(left))
-          return Constructor(left, right);
-        if (TypeGuard.TDate(left))
-          return Date2(left, right);
-        if (TypeGuard.TFunction(left))
-          return Function(left, right);
-        if (TypeGuard.TInteger(left))
-          return Integer(left, right);
-        if (TypeGuard.TIntersect(left))
-          return Intersect(left, right);
-        if (TypeGuard.TLiteral(left))
-          return Literal(left, right);
-        if (TypeGuard.TNever(left))
-          return Never(left, right);
-        if (TypeGuard.TNull(left))
-          return Null(left, right);
-        if (TypeGuard.TNumber(left))
-          return Number2(left, right);
-        if (TypeGuard.TObject(left))
-          return Object2(left, right);
-        if (TypeGuard.TRecord(left))
-          return Record(left, right);
-        if (TypeGuard.TString(left))
-          return String2(left, right);
-        if (TypeGuard.TSymbol(left))
-          return Symbol2(left, right);
-        if (TypeGuard.TTuple(left))
-          return Tuple(left, right);
-        if (TypeGuard.TPromise(left))
-          return Promise2(left, right);
-        if (TypeGuard.TUint8Array(left))
-          return Uint8Array(left, right);
-        if (TypeGuard.TUndefined(left))
-          return Undefined(left, right);
-        if (TypeGuard.TUnion(left))
-          return Union(left, right);
-        if (TypeGuard.TUnknown(left))
-          return Unknown(left, right);
-        if (TypeGuard.TVoid(left))
-          return Void(left, right);
-        throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
-      }
-      function Extends(left, right) {
-        return Visit(left, right);
-      }
-      TypeExtends2.Extends = Extends;
-    })(TypeExtends = exports.TypeExtends || (exports.TypeExtends = {}));
-    var TypeClone;
-    (function(TypeClone2) {
-      function IsObject(value) {
-        return typeof value === "object" && value !== null;
-      }
-      function IsArray(value) {
-        return globalThis.Array.isArray(value);
-      }
-      function Array2(value) {
-        return value.map((value2) => Visit(value2));
-      }
-      function Object2(value) {
-        const clonedProperties = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
-          return { ...acc, [key]: Visit(value[key]) };
-        }, {});
-        const clonedSymbols = globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => {
-          return { ...acc, [key]: Visit(value[key]) };
-        }, {});
-        return { ...clonedProperties, ...clonedSymbols };
-      }
-      function Visit(value) {
-        if (IsArray(value))
-          return Array2(value);
-        if (IsObject(value))
-          return Object2(value);
-        return value;
-      }
-      function Clone(schema, options) {
-        return { ...Visit(schema), ...options };
-      }
-      TypeClone2.Clone = Clone;
-    })(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
-    var ObjectMap;
-    (function(ObjectMap2) {
-      function Intersect(schema, callback) {
-        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
-      }
-      function Union(schema, callback) {
-        return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
-      }
-      function Object2(schema, callback) {
-        return callback(schema);
-      }
-      function Visit(schema, callback) {
-        if (schema[exports.Kind] === "Intersect")
-          return Intersect(schema, callback);
-        if (schema[exports.Kind] === "Union")
-          return Union(schema, callback);
-        if (schema[exports.Kind] === "Object")
-          return Object2(schema, callback);
-        return schema;
-      }
-      function Map2(schema, callback, options) {
-        return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
-      }
-      ObjectMap2.Map = Map2;
-    })(ObjectMap = exports.ObjectMap || (exports.ObjectMap = {}));
-    var KeyResolver;
-    (function(KeyResolver2) {
-      function IsKeyable(schema) {
-        return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || TypeGuard.TObject(schema) && globalThis.Object.getOwnPropertyNames(schema.properties).length > 0;
-      }
-      function Intersect(schema) {
-        return [...schema.allOf.filter((schema2) => IsKeyable(schema2)).reduce((set, schema2) => Visit(schema2).map((key) => set.add(key))[0], /* @__PURE__ */ new Set())];
-      }
-      function Union(schema) {
-        const sets = schema.anyOf.filter((schema2) => IsKeyable(schema2)).map((inner) => Visit(inner));
-        return [...sets.reduce((set, outer) => outer.map((key) => sets.every((inner) => inner.includes(key)) ? set.add(key) : set)[0], /* @__PURE__ */ new Set())];
-      }
-      function Object2(schema) {
-        return globalThis.Object.keys(schema.properties);
-      }
-      function Visit(schema) {
-        if (TypeGuard.TIntersect(schema))
-          return Intersect(schema);
-        if (TypeGuard.TUnion(schema))
-          return Union(schema);
-        if (TypeGuard.TObject(schema))
-          return Object2(schema);
-        return [];
-      }
-      function Resolve(schema) {
-        return Visit(schema);
-      }
-      KeyResolver2.Resolve = Resolve;
-    })(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
-    var TemplateLiteralPattern;
-    (function(TemplateLiteralPattern2) {
-      function Escape(value) {
-        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      }
-      function Visit(schema, acc) {
-        if (TypeGuard.TTemplateLiteral(schema)) {
-          const pattern = schema.pattern.slice(1, schema.pattern.length - 1);
-          return pattern;
-        } else if (TypeGuard.TUnion(schema)) {
-          const tokens = schema.anyOf.map((schema2) => Visit(schema2, acc)).join("|");
-          return `(${tokens})`;
-        } else if (TypeGuard.TNumber(schema)) {
-          return `${acc}${exports.PatternNumber}`;
-        } else if (TypeGuard.TInteger(schema)) {
-          return `${acc}${exports.PatternNumber}`;
-        } else if (TypeGuard.TBigInt(schema)) {
-          return `${acc}${exports.PatternNumber}`;
-        } else if (TypeGuard.TString(schema)) {
-          return `${acc}${exports.PatternString}`;
-        } else if (TypeGuard.TLiteral(schema)) {
-          return `${acc}${Escape(schema.const.toString())}`;
-        } else if (TypeGuard.TBoolean(schema)) {
-          return `${acc}${exports.PatternBoolean}`;
-        } else if (TypeGuard.TNever(schema)) {
-          throw Error("TemplateLiteralPattern: TemplateLiteral cannot operate on types of TNever");
-        } else {
-          throw Error(`TemplateLiteralPattern: Unexpected Kind '${schema[exports.Kind]}'`);
-        }
-      }
-      function Create(kinds) {
-        return `^${kinds.map((schema) => Visit(schema, "")).join("")}$`;
-      }
-      TemplateLiteralPattern2.Create = Create;
-    })(TemplateLiteralPattern = exports.TemplateLiteralPattern || (exports.TemplateLiteralPattern = {}));
-    var TemplateLiteralResolver;
-    (function(TemplateLiteralResolver2) {
-      function Resolve(template) {
-        const expression = TemplateLiteralParser.ParseExact(template.pattern);
-        if (!TemplateLiteralFinite.Check(expression))
-          return exports.Type.String();
-        const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => exports.Type.Literal(value));
-        return exports.Type.Union(literals);
-      }
-      TemplateLiteralResolver2.Resolve = Resolve;
-    })(TemplateLiteralResolver = exports.TemplateLiteralResolver || (exports.TemplateLiteralResolver = {}));
-    var TemplateLiteralParserError = class extends Error {
-      constructor(message) {
-        super(message);
-      }
-    };
-    exports.TemplateLiteralParserError = TemplateLiteralParserError;
-    var TemplateLiteralParser;
-    (function(TemplateLiteralParser2) {
-      function IsNonEscaped(pattern, index, char) {
-        return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
-      }
-      function IsOpenParen(pattern, index) {
-        return IsNonEscaped(pattern, index, "(");
-      }
-      function IsCloseParen(pattern, index) {
-        return IsNonEscaped(pattern, index, ")");
-      }
-      function IsSeparator(pattern, index) {
-        return IsNonEscaped(pattern, index, "|");
-      }
-      function IsGroup(pattern) {
-        if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
-          return false;
-        let count = 0;
-        for (let index = 0; index < pattern.length; index++) {
-          if (IsOpenParen(pattern, index))
-            count += 1;
-          if (IsCloseParen(pattern, index))
-            count -= 1;
-          if (count === 0 && index !== pattern.length - 1)
-            return false;
-        }
-        return true;
-      }
-      function InGroup(pattern) {
-        return pattern.slice(1, pattern.length - 1);
-      }
-      function IsPrecedenceOr(pattern) {
-        let count = 0;
-        for (let index = 0; index < pattern.length; index++) {
-          if (IsOpenParen(pattern, index))
-            count += 1;
-          if (IsCloseParen(pattern, index))
-            count -= 1;
-          if (IsSeparator(pattern, index) && count === 0)
-            return true;
-        }
-        return false;
-      }
-      function IsPrecedenceAnd(pattern) {
-        for (let index = 0; index < pattern.length; index++) {
-          if (IsOpenParen(pattern, index))
-            return true;
-        }
-        return false;
-      }
-      function Or(pattern) {
-        let [count, start] = [0, 0];
-        const expressions = [];
-        for (let index = 0; index < pattern.length; index++) {
-          if (IsOpenParen(pattern, index))
-            count += 1;
-          if (IsCloseParen(pattern, index))
-            count -= 1;
-          if (IsSeparator(pattern, index) && count === 0) {
-            const range2 = pattern.slice(start, index);
-            if (range2.length > 0)
-              expressions.push(Parse(range2));
-            start = index + 1;
-          }
-        }
-        const range = pattern.slice(start);
-        if (range.length > 0)
-          expressions.push(Parse(range));
-        if (expressions.length === 0)
-          return { type: "const", const: "" };
-        if (expressions.length === 1)
-          return expressions[0];
-        return { type: "or", expr: expressions };
-      }
-      function And(pattern) {
-        function Group(value, index) {
-          if (!IsOpenParen(value, index))
-            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
-          let count = 0;
-          for (let scan = index; scan < value.length; scan++) {
-            if (IsOpenParen(value, scan))
-              count += 1;
-            if (IsCloseParen(value, scan))
-              count -= 1;
-            if (count === 0)
-              return [index, scan];
-          }
-          throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
-        }
-        function Range(pattern2, index) {
-          for (let scan = index; scan < pattern2.length; scan++) {
-            if (IsOpenParen(pattern2, scan))
-              return [index, scan];
-          }
-          return [index, pattern2.length];
-        }
-        const expressions = [];
-        for (let index = 0; index < pattern.length; index++) {
-          if (IsOpenParen(pattern, index)) {
-            const [start, end] = Group(pattern, index);
-            const range = pattern.slice(start, end + 1);
-            expressions.push(Parse(range));
-            index = end;
-          } else {
-            const [start, end] = Range(pattern, index);
-            const range = pattern.slice(start, end);
-            if (range.length > 0)
-              expressions.push(Parse(range));
-            index = end - 1;
-          }
-        }
-        if (expressions.length === 0)
-          return { type: "const", const: "" };
-        if (expressions.length === 1)
-          return expressions[0];
-        return { type: "and", expr: expressions };
-      }
-      function Parse(pattern) {
-        if (IsGroup(pattern))
-          return Parse(InGroup(pattern));
-        if (IsPrecedenceOr(pattern))
-          return Or(pattern);
-        if (IsPrecedenceAnd(pattern))
-          return And(pattern);
-        return { type: "const", const: pattern };
-      }
-      TemplateLiteralParser2.Parse = Parse;
-      function ParseExact(pattern) {
-        return Parse(pattern.slice(1, pattern.length - 1));
-      }
-      TemplateLiteralParser2.ParseExact = ParseExact;
-    })(TemplateLiteralParser = exports.TemplateLiteralParser || (exports.TemplateLiteralParser = {}));
-    var TemplateLiteralFinite;
-    (function(TemplateLiteralFinite2) {
-      function IsNumber(expression) {
-        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
-      }
-      function IsBoolean(expression) {
-        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
-      }
-      function IsString(expression) {
-        return expression.type === "const" && expression.const === ".*";
-      }
-      function Check(expression) {
-        if (IsBoolean(expression))
-          return true;
-        if (IsNumber(expression) || IsString(expression))
-          return false;
-        if (expression.type === "and")
-          return expression.expr.every((expr) => Check(expr));
-        if (expression.type === "or")
-          return expression.expr.every((expr) => Check(expr));
-        if (expression.type === "const")
-          return true;
-        throw Error(`TemplateLiteralFinite: Unknown expression type`);
-      }
-      TemplateLiteralFinite2.Check = Check;
-    })(TemplateLiteralFinite = exports.TemplateLiteralFinite || (exports.TemplateLiteralFinite = {}));
-    var TemplateLiteralGenerator;
-    (function(TemplateLiteralGenerator2) {
-      function* Reduce(buffer) {
-        if (buffer.length === 1)
-          return yield* buffer[0];
-        for (const left of buffer[0]) {
-          for (const right of Reduce(buffer.slice(1))) {
-            yield `${left}${right}`;
-          }
-        }
-      }
-      function* And(expression) {
-        return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]));
-      }
-      function* Or(expression) {
-        for (const expr of expression.expr)
-          yield* Generate(expr);
-      }
-      function* Const(expression) {
-        return yield expression.const;
-      }
-      function* Generate(expression) {
-        if (expression.type === "and")
-          return yield* And(expression);
-        if (expression.type === "or")
-          return yield* Or(expression);
-        if (expression.type === "const")
-          return yield* Const(expression);
-        throw Error("TemplateLiteralGenerator: Unknown expression");
-      }
-      TemplateLiteralGenerator2.Generate = Generate;
-    })(TemplateLiteralGenerator = exports.TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = {}));
-    var TypeOrdinal = 0;
-    var TypeBuilder = class {
-      /** `[Utility]` Creates a schema without `static` and `params` types */
-      Create(schema) {
-        return schema;
-      }
-      /** `[Standard]` Omits compositing symbols from this schema */
-      Strict(schema) {
-        return JSON.parse(JSON.stringify(schema));
-      }
-    };
-    exports.TypeBuilder = TypeBuilder;
-    var StandardTypeBuilder = class extends TypeBuilder {
-      // ------------------------------------------------------------------------
-      // Modifiers
-      // ------------------------------------------------------------------------
-      /** `[Modifier]` Creates a Optional property */
-      Optional(schema) {
-        return { [exports.Modifier]: "Optional", ...TypeClone.Clone(schema, {}) };
-      }
-      /** `[Modifier]` Creates a ReadonlyOptional property */
-      ReadonlyOptional(schema) {
-        return { [exports.Modifier]: "ReadonlyOptional", ...TypeClone.Clone(schema, {}) };
-      }
-      /** `[Modifier]` Creates a Readonly object or property */
-      Readonly(schema) {
-        return { [exports.Modifier]: "Readonly", ...schema };
-      }
-      // ------------------------------------------------------------------------
-      // Types
-      // ------------------------------------------------------------------------
-      /** `[Standard]` Creates an Any type */
-      Any(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Any" });
-      }
-      /** `[Standard]` Creates an Array type */
-      Array(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Array", type: "array", items: TypeClone.Clone(items, {}) });
-      }
-      /** `[Standard]` Creates a Boolean type */
-      Boolean(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Boolean", type: "boolean" });
-      }
-      /** `[Standard]` Creates a Composite object type. */
-      Composite(objects, options) {
-        const isOptionalAll = (objects2, key) => objects2.every((object) => !(key in object.properties) || IsOptional(object.properties[key]));
-        const IsOptional = (schema) => TypeGuard.TOptional(schema) || TypeGuard.TReadonlyOptional(schema);
-        const [required, optional] = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
-        for (const object of objects) {
-          for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
-            if (isOptionalAll(objects, key))
-              optional.add(key);
-          }
-        }
-        for (const object of objects) {
-          for (const key of globalThis.Object.getOwnPropertyNames(object.properties)) {
-            if (!optional.has(key))
-              required.add(key);
-          }
-        }
-        const properties = {};
-        for (const object of objects) {
-          for (const [key, schema] of Object.entries(object.properties)) {
-            const property = TypeClone.Clone(schema, {});
-            if (!optional.has(key))
-              delete property[exports.Modifier];
-            if (key in properties) {
-              const left = TypeExtends.Extends(properties[key], property) !== TypeExtendsResult.False;
-              const right = TypeExtends.Extends(property, properties[key]) !== TypeExtendsResult.False;
-              if (!left && !right)
-                properties[key] = exports.Type.Never();
-              if (!left && right)
-                properties[key] = property;
-            } else {
-              properties[key] = property;
-            }
-          }
-        }
-        if (required.size > 0) {
-          return this.Create({ ...options, [exports.Kind]: "Object", [exports.Hint]: "Composite", type: "object", properties, required: [...required] });
-        } else {
-          return this.Create({ ...options, [exports.Kind]: "Object", [exports.Hint]: "Composite", type: "object", properties });
-        }
-      }
-      /** `[Standard]` Creates a Enum type */
-      Enum(item, options = {}) {
-        const values = globalThis.Object.keys(item).filter((key) => isNaN(key)).map((key) => item[key]);
-        const anyOf = values.map((value) => typeof value === "string" ? { [exports.Kind]: "Literal", type: "string", const: value } : { [exports.Kind]: "Literal", type: "number", const: value });
-        return this.Create({ ...options, [exports.Kind]: "Union", anyOf });
-      }
-      /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
-      Extends(left, right, trueType, falseType, options = {}) {
-        switch (TypeExtends.Extends(left, right)) {
-          case TypeExtendsResult.Union:
-            return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]);
-          case TypeExtendsResult.True:
-            return TypeClone.Clone(trueType, options);
-          case TypeExtendsResult.False:
-            return TypeClone.Clone(falseType, options);
-        }
-      }
-      /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
-      Exclude(left, right, options = {}) {
-        if (TypeGuard.TTemplateLiteral(left))
-          return this.Exclude(TemplateLiteralResolver.Resolve(left), right, options);
-        if (TypeGuard.TTemplateLiteral(right))
-          return this.Exclude(left, TemplateLiteralResolver.Resolve(right), options);
-        if (TypeGuard.TUnion(left)) {
-          const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
-          return narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options);
-        } else {
-          return TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options);
-        }
-      }
-      /** `[Standard]` Extracts from the left type any type that is assignable to the right */
-      Extract(left, right, options = {}) {
-        if (TypeGuard.TTemplateLiteral(left))
-          return this.Extract(TemplateLiteralResolver.Resolve(left), right, options);
-        if (TypeGuard.TTemplateLiteral(right))
-          return this.Extract(left, TemplateLiteralResolver.Resolve(right), options);
-        if (TypeGuard.TUnion(left)) {
-          const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
-          return narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options);
-        } else {
-          return TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options);
-        }
-      }
-      /** `[Standard]` Creates an Integer type */
-      Integer(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Integer", type: "integer" });
-      }
-      Intersect(allOf, options = {}) {
-        if (allOf.length === 0)
-          return exports.Type.Never();
-        if (allOf.length === 1)
-          return TypeClone.Clone(allOf[0], options);
-        const objects = allOf.every((schema) => TypeGuard.TObject(schema));
-        const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}));
-        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {};
-        if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
-          return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", type: "object", allOf: cloned });
-        } else {
-          return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", allOf: cloned });
-        }
-      }
-      /** `[Standard]` Creates a KeyOf type */
-      KeyOf(schema, options = {}) {
-        if (TypeGuard.TRecord(schema)) {
-          const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-          if (pattern === exports.PatternNumberExact)
-            return this.Number(options);
-          if (pattern === exports.PatternStringExact)
-            return this.String(options);
-          throw Error("StandardTypeBuilder: Unable to resolve key type from Record key pattern");
-        } else {
-          const resolved = KeyResolver.Resolve(schema);
-          if (resolved.length === 0)
-            return this.Never(options);
-          const literals = resolved.map((key) => this.Literal(key));
-          return this.Union(literals, options);
-        }
-      }
-      /** `[Standard]` Creates a Literal type */
-      Literal(value, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Literal", const: value, type: typeof value });
-      }
-      /** `[Standard]` Creates a Never type */
-      Never(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Never", not: {} });
-      }
-      /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
-      Not(not, schema, options) {
-        return this.Create({ ...options, [exports.Kind]: "Not", allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] });
-      }
-      /** `[Standard]` Creates a Null type */
-      Null(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Null", type: "null" });
-      }
-      /** `[Standard]` Creates a Number type */
-      Number(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Number", type: "number" });
-      }
-      /** `[Standard]` Creates an Object type */
-      Object(properties, options = {}) {
-        const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
-        const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
-        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {});
-        if (requiredKeys.length > 0) {
-          return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties, required: requiredKeys });
-        } else {
-          return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties });
-        }
-      }
-      Omit(schema, unresolved, options = {}) {
-        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema2) => schema2.const) : TypeGuard.TLiteral(unresolved) ? [unresolved.const] : TypeGuard.TNever(unresolved) ? [] : unresolved;
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
-          if (schema2.required) {
-            schema2.required = schema2.required.filter((key) => !keys.includes(key));
-            if (schema2.required.length === 0)
-              delete schema2.required;
-          }
-          for (const key of globalThis.Object.keys(schema2.properties)) {
-            if (keys.includes(key))
-              delete schema2.properties[key];
-          }
-          return this.Create(schema2);
-        }, options);
-      }
-      /** `[Standard]` Creates a mapped type where all properties are Optional */
-      Partial(schema, options = {}) {
-        function Apply(schema2) {
-          switch (schema2[exports.Modifier]) {
-            case "ReadonlyOptional":
-              schema2[exports.Modifier] = "ReadonlyOptional";
-              break;
-            case "Readonly":
-              schema2[exports.Modifier] = "ReadonlyOptional";
-              break;
-            case "Optional":
-              schema2[exports.Modifier] = "Optional";
-              break;
-            default:
-              schema2[exports.Modifier] = "Optional";
-              break;
-          }
-        }
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
-          delete schema2.required;
-          globalThis.Object.keys(schema2.properties).forEach((key) => Apply(schema2.properties[key]));
-          return schema2;
-        }, options);
-      }
-      Pick(schema, unresolved, options = {}) {
-        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema2) => schema2.const) : TypeGuard.TLiteral(unresolved) ? [unresolved.const] : TypeGuard.TNever(unresolved) ? [] : unresolved;
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
-          if (schema2.required) {
-            schema2.required = schema2.required.filter((key) => keys.includes(key));
-            if (schema2.required.length === 0)
-              delete schema2.required;
-          }
-          for (const key of globalThis.Object.keys(schema2.properties)) {
-            if (!keys.includes(key))
-              delete schema2.properties[key];
-          }
-          return this.Create(schema2);
-        }, options);
-      }
-      /** `[Standard]` Creates a Record type */
-      Record(key, schema, options = {}) {
-        if (TypeGuard.TTemplateLiteral(key)) {
-          const expression = TemplateLiteralParser.ParseExact(key.pattern);
-          return TemplateLiteralFinite.Check(expression) ? this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key2) => ({ ...acc, [key2]: TypeClone.Clone(schema, {}) }), {}), options) : this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
-        } else if (TypeGuard.TUnionLiteral(key)) {
-          if (key.anyOf.every((schema2) => TypeGuard.TLiteral(schema2) && (typeof schema2.const === "string" || typeof schema2.const === "number"))) {
-            const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
-            return this.Object(properties, { ...options, [exports.Hint]: "Record" });
-          } else
-            throw Error("TypeBuilder: Record key can only be derived from union literal of number or string");
-        } else if (TypeGuard.TLiteral(key)) {
-          if (typeof key.const === "string" || typeof key.const === "number") {
-            return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
-          } else
-            throw Error("TypeBuilder: Record key can only be derived from literals of number or string");
-        } else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-          const pattern = exports.PatternNumberExact;
-          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
-        } else if (TypeGuard.TString(key)) {
-          const pattern = key.pattern === void 0 ? exports.PatternStringExact : key.pattern;
-          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [pattern]: TypeClone.Clone(schema, {}) }, additionalProperties: false });
-        } else {
-          throw Error(`StandardTypeBuilder: Invalid Record Key`);
-        }
-      }
-      /** `[Standard]` Creates a Recursive type */
-      Recursive(callback, options = {}) {
-        if (options.$id === void 0)
-          options.$id = `T${TypeOrdinal++}`;
-        const thisType = callback({ [exports.Kind]: "This", $ref: `${options.$id}` });
-        thisType.$id = options.$id;
-        return this.Create({ ...options, [exports.Hint]: "Recursive", ...thisType });
-      }
-      /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
-      Ref(schema, options = {}) {
-        if (schema.$id === void 0)
-          throw Error("StandardTypeBuilder.Ref: Target type must specify an $id");
-        return this.Create({ ...options, [exports.Kind]: "Ref", $ref: schema.$id });
-      }
-      /** `[Standard]` Creates a mapped type where all properties are Required */
-      Required(schema, options = {}) {
-        function Apply(schema2) {
-          switch (schema2[exports.Modifier]) {
-            case "ReadonlyOptional":
-              schema2[exports.Modifier] = "Readonly";
-              break;
-            case "Readonly":
-              schema2[exports.Modifier] = "Readonly";
-              break;
-            case "Optional":
-              delete schema2[exports.Modifier];
-              break;
-            default:
-              delete schema2[exports.Modifier];
-              break;
-          }
-        }
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema2) => {
-          schema2.required = globalThis.Object.keys(schema2.properties);
-          globalThis.Object.keys(schema2.properties).forEach((key) => Apply(schema2.properties[key]));
-          return schema2;
-        }, options);
-      }
-      /** `[Standard]` Creates a String type */
-      String(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "String", type: "string" });
-      }
-      /** `[Standard]` Creates a template literal type */
-      TemplateLiteral(kinds, options = {}) {
-        const pattern = TemplateLiteralPattern.Create(kinds);
-        return this.Create({ ...options, [exports.Kind]: "TemplateLiteral", type: "string", pattern });
-      }
-      /** `[Standard]` Creates a Tuple type */
-      Tuple(items, options = {}) {
-        const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-        const clonedItems = items.map((item) => TypeClone.Clone(item, {}));
-        const schema = items.length > 0 ? { ...options, [exports.Kind]: "Tuple", type: "array", items: clonedItems, additionalItems, minItems, maxItems } : { ...options, [exports.Kind]: "Tuple", type: "array", minItems, maxItems };
-        return this.Create(schema);
-      }
-      Union(union, options = {}) {
-        if (TypeGuard.TTemplateLiteral(union)) {
-          return TemplateLiteralResolver.Resolve(union);
-        } else {
-          const anyOf = union;
-          if (anyOf.length === 0)
-            return this.Never(options);
-          if (anyOf.length === 1)
-            return this.Create(TypeClone.Clone(anyOf[0], options));
-          const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
-          return this.Create({ ...options, [exports.Kind]: "Union", anyOf: clonedAnyOf });
-        }
-      }
-      /** `[Standard]` Creates an Unknown type */
-      Unknown(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Unknown" });
-      }
-      /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
-      Unsafe(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || "Unsafe" });
-      }
-    };
-    exports.StandardTypeBuilder = StandardTypeBuilder;
-    var ExtendedTypeBuilder = class extends StandardTypeBuilder {
-      /** `[Extended]` Creates a BigInt type */
-      BigInt(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "BigInt", type: "null", typeOf: "BigInt" });
-      }
-      /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
-      ConstructorParameters(schema, options = {}) {
-        return this.Tuple([...schema.parameters], { ...options });
-      }
-      Constructor(parameters, returns, options = {}) {
-        const clonedReturns = TypeClone.Clone(returns, {});
-        if (TypeGuard.TTuple(parameters)) {
-          const clonedParameters = parameters.items === void 0 ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
-          return this.Create({ ...options, [exports.Kind]: "Constructor", type: "object", instanceOf: "Constructor", parameters: clonedParameters, returns: clonedReturns });
-        } else if (globalThis.Array.isArray(parameters)) {
-          const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
-          return this.Create({ ...options, [exports.Kind]: "Constructor", type: "object", instanceOf: "Constructor", parameters: clonedParameters, returns: clonedReturns });
-        } else {
-          throw new Error("ExtendedTypeBuilder.Constructor: Invalid parameters");
-        }
-      }
-      /** `[Extended]` Creates a Date type */
-      Date(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Date", type: "object", instanceOf: "Date" });
-      }
-      Function(parameters, returns, options = {}) {
-        const clonedReturns = TypeClone.Clone(returns, {});
-        if (TypeGuard.TTuple(parameters)) {
-          const clonedParameters = parameters.items === void 0 ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
-          return this.Create({ ...options, [exports.Kind]: "Function", type: "object", instanceOf: "Function", parameters: clonedParameters, returns: clonedReturns });
-        } else if (globalThis.Array.isArray(parameters)) {
-          const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
-          return this.Create({ ...options, [exports.Kind]: "Function", type: "object", instanceOf: "Function", parameters: clonedParameters, returns: clonedReturns });
-        } else {
-          throw new Error("ExtendedTypeBuilder.Function: Invalid parameters");
-        }
-      }
-      /** `[Extended]` Extracts the InstanceType from the given Constructor */
-      InstanceType(schema, options = {}) {
-        return TypeClone.Clone(schema.returns, options);
-      }
-      /** `[Extended]` Extracts the Parameters from the given Function type */
-      Parameters(schema, options = {}) {
-        return this.Tuple(schema.parameters, { ...options });
-      }
-      /** `[Extended]` Creates a Promise type */
-      Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Promise", type: "object", instanceOf: "Promise", item: TypeClone.Clone(item, {}) });
-      }
-      /** `[Extended]` Creates a regular expression type */
-      RegEx(regex, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "String", type: "string", pattern: regex.source });
-      }
-      /** `[Extended]` Extracts the ReturnType from the given Function */
-      ReturnType(schema, options = {}) {
-        return TypeClone.Clone(schema.returns, options);
-      }
-      /** `[Extended]` Creates a Symbol type */
-      Symbol(options) {
-        return this.Create({ ...options, [exports.Kind]: "Symbol", type: "null", typeOf: "Symbol" });
-      }
-      /** `[Extended]` Creates a Undefined type */
-      Undefined(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Undefined", type: "null", typeOf: "Undefined" });
-      }
-      /** `[Extended]` Creates a Uint8Array type */
-      Uint8Array(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Uint8Array", type: "object", instanceOf: "Uint8Array" });
-      }
-      /** `[Extended]` Creates a Void type */
-      Void(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: "Void", type: "null", typeOf: "Void" });
-      }
-    };
-    exports.ExtendedTypeBuilder = ExtendedTypeBuilder;
-    exports.StandardType = new StandardTypeBuilder();
-    exports.Type = new ExtendedTypeBuilder();
-  }
-});
-
-// src/plugin/index.ts
-var import_typebox = __toESM(require_typebox(), 1);
-import { execFileSync as execFileSync2, execFile } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, renameSync, statSync as statSync3 } from "fs";
-import { join as join5, basename } from "path";
-
-// src/plugin/templates.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "path";
-var DEFAULT_SCHEMAS = [
-  {
-    primitive: "memory_event",
-    description: "General memory event for observations",
-    fields: {
-      type: { type: "string", required: true, default: "memory_event" },
-      status: { type: "string", required: true, default: "recorded", enum: ["recorded", "superseded", "corrected"] },
-      created: { type: "datetime", required: true, default: "{{datetime}}" },
-      observed_at: { type: "datetime", required: true },
-      source: { type: "string", required: true, enum: ["openclaw", "claude-code", "replay", "manual-correction"] },
-      summary: { type: "string", required: true },
-      confidence: { type: "number" },
-      importance: { type: "number" }
-    },
-    keywords: ["preference", "like", "hate", "want", "need", "always", "never", "remember", "note"]
-  },
-  {
-    primitive: "person",
-    description: "People and relationship notes",
-    fields: {
-      title: { type: "string", required: true, default: "{{title}}" },
-      date: { type: "date", required: true, default: "{{date}}" },
-      type: { type: "string", required: true, default: "person" },
-      relationship: { type: "string", default: "contact" }
-    },
-    keywords: ["person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is"]
-  },
-  {
-    primitive: "decision",
-    description: "Decision records",
-    fields: {
-      title: { type: "string", required: true, default: "{{title}}" },
-      date: { type: "date", required: true, default: "{{date}}" },
-      type: { type: "string", required: true, default: "decision" },
-      status: { type: "string", default: "decided", enum: ["proposed", "decided", "superseded"] }
-    },
-    keywords: ["decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected"]
-  },
-  {
-    primitive: "task",
-    description: "Task primitives",
-    fields: {
-      status: { type: "string", required: true, default: "open", enum: ["open", "in-progress", "blocked", "done"] },
-      created: { type: "datetime", required: true, default: "{{datetime}}" },
-      updated: { type: "datetime", required: true, default: "{{datetime}}" },
-      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-      due: { type: "date" }
-    },
-    keywords: ["task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight"]
-  },
-  {
-    primitive: "project",
-    description: "Project definition documents",
-    fields: {
-      type: { type: "string", required: true, default: "project" },
-      status: { type: "string", required: true, default: "active", enum: ["active", "paused", "completed", "archived"] },
-      created: { type: "datetime", required: true, default: "{{datetime}}" },
-      updated: { type: "datetime", required: true, default: "{{datetime}}" }
-    },
-    keywords: ["project", "initiative", "working on", "building", "developing"]
-  },
-  {
-    primitive: "lesson",
-    description: "Lessons learned",
-    fields: {
-      title: { type: "string", required: true, default: "{{title}}" },
-      date: { type: "date", required: true, default: "{{date}}" },
-      type: { type: "string", required: true, default: "lesson" }
-    },
-    keywords: ["learned", "lesson", "insight", "realized", "discovered", "found out"]
-  }
-];
-function parseYamlFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  try {
-    const frontmatter = parseSimpleYaml(match[1]);
-    return { frontmatter, body: match[2] };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleYaml(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  let currentKey = "";
-  let nestedObject = null;
-  let nestedKey = "";
-  for (const line of lines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const indent = line.search(/\S/);
-    const trimmed = line.trim();
-    if (trimmed.startsWith("- ")) {
-      const value = trimmed.slice(2).trim();
-      if (nestedObject && nestedKey) {
-        const arr = nestedObject[nestedKey];
-        if (Array.isArray(arr)) arr.push(parseYamlValue(value));
-      } else if (currentKey && result[currentKey]) {
-        const arr = result[currentKey];
-        if (Array.isArray(arr)) arr.push(parseYamlValue(value));
-      }
-      continue;
-    }
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = trimmed.slice(0, colonIndex).trim();
-    const valueStr = trimmed.slice(colonIndex + 1).trim();
-    if (indent === 0) {
-      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-        if (key === "fields") {
-          result[key] = {};
-          nestedObject = result[key];
-          nestedKey = "";
-        } else {
-          result[key] = {};
-          nestedObject = null;
-        }
-      } else {
-        result[key] = parseYamlValue(valueStr);
-        nestedObject = null;
-      }
-      currentKey = key;
-    } else if (nestedObject && indent > 0) {
-      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-        nestedObject[key] = {};
-        nestedKey = key;
-      } else if (nestedKey && indent > 2) {
-        const fieldObj = nestedObject[nestedKey];
-        if (fieldObj) {
-          if (key === "enum") {
-            fieldObj[key] = [];
-          } else {
-            fieldObj[key] = parseYamlValue(valueStr);
-          }
-        }
-      } else {
-        nestedObject[key] = parseYamlValue(valueStr);
-        nestedKey = key;
-      }
-    }
-  }
-  return result;
-}
-function parseYamlValue(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-var registry = null;
-function getTemplateRegistry() {
-  if (!registry) {
-    registry = {
-      schemas: /* @__PURE__ */ new Map(),
-      keywordIndex: /* @__PURE__ */ new Map(),
-      initialized: false
-    };
-  }
-  return registry;
-}
-function initializeTemplateRegistry(templatesDir) {
-  const reg = getTemplateRegistry();
-  if (reg.initialized) return reg;
-  const dirsToTry = templatesDir ? [templatesDir] : [
-    join(process.cwd(), "templates"),
-    join(process.cwd(), "..", "..", "templates"),
-    join(process.env.HOME ?? ".", "clawvault", "templates"),
-    join(process.env.HOME ?? ".", ".clawvault", "templates")
-  ];
-  let loaded = false;
-  for (const dir of dirsToTry) {
-    if (existsSync(dir)) {
-      try {
-        loadTemplatesFromDirectory(dir, reg);
-        loaded = true;
-        break;
-      } catch {
-      }
-    }
-  }
-  if (!loaded || reg.schemas.size === 0) {
-    loadDefaultSchemas(reg);
-  }
-  buildKeywordIndex(reg);
-  reg.initialized = true;
-  return reg;
-}
-function loadTemplatesFromDirectory(dir, reg) {
-  const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
-  for (const file of files) {
-    const filePath = join(dir, file);
-    const content = readFileSync(filePath, "utf-8");
-    const parsed = parseYamlFrontmatter(content);
-    if (!parsed?.frontmatter?.primitive) continue;
-    const schema = convertFrontmatterToSchema(
-      parsed.frontmatter,
-      parsed.body
-    );
-    if (schema) {
-      reg.schemas.set(schema.primitive, schema);
-    }
-  }
-}
-function convertFrontmatterToSchema(fm, body) {
-  const primitive = fm.primitive;
-  if (!primitive) return null;
-  const fields = {};
-  const fmFields = fm.fields;
-  if (fmFields) {
-    for (const [fieldName, fieldDef] of Object.entries(fmFields)) {
-      if (typeof fieldDef === "object" && fieldDef !== null) {
-        fields[fieldName] = {
-          type: fieldDef.type || "string",
-          required: fieldDef.required,
-          default: fieldDef.default,
-          enum: fieldDef.enum,
-          description: fieldDef.description
-        };
-      }
-    }
-  }
-  const keywords = extractKeywordsFromSchema(primitive, fm.description, fields);
-  return {
-    primitive,
-    description: fm.description,
-    fields,
-    bodyTemplate: body,
-    keywords
-  };
-}
-function extractKeywordsFromSchema(primitive, _description, fields) {
-  const keywords = [primitive];
-  keywords.push(primitive.replace(/-/g, " "));
-  keywords.push(primitive.replace(/_/g, " "));
-  const keywordMap = {
-    memory_event: ["preference", "like", "hate", "want", "need", "always", "never", "remember", "note"],
-    person: ["person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is"],
-    decision: ["decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected"],
-    task: ["task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight"],
-    project: ["project", "initiative", "working on", "building", "developing"],
-    lesson: ["learned", "lesson", "insight", "realized", "discovered", "found out"],
-    trigger: ["trigger", "schedule", "cron", "automated", "recurring"],
-    run: ["run", "execution", "job", "started", "finished", "failed"],
-    checkpoint: ["checkpoint", "snapshot", "state", "progress"],
-    handoff: ["handoff", "transition", "context", "resume"],
-    "daily-note": ["daily", "today", "journal", "log"],
-    daily: ["daily", "today", "journal", "log"],
-    party: ["party", "agent", "human", "runtime", "service"],
-    workspace: ["workspace", "shared", "collaboration"]
-  };
-  if (keywordMap[primitive]) {
-    keywords.push(...keywordMap[primitive]);
-  }
-  if (fields.status?.enum) {
-    keywords.push(...fields.status.enum);
-  }
-  return [...new Set(keywords)];
-}
-function loadDefaultSchemas(reg) {
-  for (const schema of DEFAULT_SCHEMAS) {
-    reg.schemas.set(schema.primitive, schema);
-  }
-}
-function buildKeywordIndex(reg) {
-  reg.keywordIndex.clear();
-  for (const [primitive, schema] of reg.schemas) {
-    const keywords = schema.keywords ?? [primitive];
-    for (const keyword of keywords) {
-      const lower = keyword.toLowerCase();
-      const existing = reg.keywordIndex.get(lower) ?? [];
-      if (!existing.includes(primitive)) {
-        existing.push(primitive);
-      }
-      reg.keywordIndex.set(lower, existing);
-    }
-  }
-}
-function classifyText(text) {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) initializeTemplateRegistry();
-  const lower = text.toLowerCase();
-  const scores = /* @__PURE__ */ new Map();
-  for (const [keyword, primitives] of reg.keywordIndex) {
-    if (lower.includes(keyword)) {
-      for (const primitive of primitives) {
-        const existing = scores.get(primitive) ?? { score: 0, keywords: [] };
-        existing.score += getKeywordWeight(keyword, primitive);
-        existing.keywords.push(keyword);
-        scores.set(primitive, existing);
-      }
-    }
-  }
-  applyPatternScoring(lower, scores);
-  let bestPrimitive = "memory_event";
-  let bestScore = 0;
-  let bestKeywords = [];
-  for (const [primitive, data] of scores) {
-    if (data.score > bestScore) {
-      bestScore = data.score;
-      bestPrimitive = primitive;
-      bestKeywords = data.keywords;
-    }
-  }
-  const confidence = Math.min(1, bestScore / 5);
-  return {
-    primitiveType: bestPrimitive,
-    confidence,
-    matchedKeywords: [...new Set(bestKeywords)]
-  };
-}
-function getKeywordWeight(keyword, primitive) {
-  if (keyword === primitive || keyword === primitive.replace(/-/g, " ")) return 3;
-  const strongIndicators = {
-    person: ["works at", "lives in", "email", "phone", "name is"],
-    decision: ["decided", "chose", "will use", "go with"],
-    task: ["deadline", "due", "by tomorrow", "by tonight"],
-    memory_event: ["preference", "remember", "note"]
-  };
-  if (strongIndicators[primitive]?.includes(keyword)) return 2;
-  return 1;
-}
-function applyPatternScoring(text, scores) {
-  const patterns = [
-    { regex: /\b(my .+ is|his .+ is|her .+ is|their .+ is)\b/i, primitive: "person", weight: 2, label: "possessive pattern" },
-    { regex: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/, primitive: "person", weight: 3, label: "contact info" },
-    { regex: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, primitive: "memory_event", weight: 3, label: "preference pattern" },
-    { regex: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it)\b/i, primitive: "decision", weight: 3, label: "decision pattern" },
-    { regex: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, primitive: "task", weight: 2, label: "deadline pattern" }
-  ];
-  for (const { regex, primitive, weight, label } of patterns) {
-    if (regex.test(text)) {
-      const existing = scores.get(primitive) ?? { score: 0, keywords: [] };
-      existing.score += weight;
-      existing.keywords.push(label);
-      scores.set(primitive, existing);
-    }
-  }
-}
-function getSchema(primitiveType) {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) initializeTemplateRegistry();
-  return reg.schemas.get(primitiveType);
-}
-function getAllSchemas() {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) initializeTemplateRegistry();
-  return Array.from(reg.schemas.values());
-}
-function getSchemaNames() {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) initializeTemplateRegistry();
-  return Array.from(reg.schemas.keys());
-}
-function generateFrontmatter(primitiveType, options = {}) {
-  const schema = getSchema(primitiveType);
-  if (!schema) {
-    return {
-      type: primitiveType,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  const frontmatter = {};
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().split("T")[0];
-  const datetimeStr = now.toISOString();
-  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-    if (options.extraFields?.[fieldName] !== void 0) {
-      const value = options.extraFields[fieldName];
-      if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
-        frontmatter[fieldName] = fieldDef.default ?? fieldDef.enum[0];
-      } else {
-        frontmatter[fieldName] = value;
-      }
-      continue;
-    }
-    if (fieldDef.default !== void 0) {
-      let defaultValue = fieldDef.default;
-      if (typeof defaultValue === "string") {
-        defaultValue = defaultValue.replace("{{datetime}}", datetimeStr).replace("{{date}}", dateStr).replace("{{title}}", options.title ?? "Untitled");
-      }
-      frontmatter[fieldName] = defaultValue;
-    } else if (fieldDef.required) {
-      switch (fieldDef.type) {
-        case "datetime":
-          frontmatter[fieldName] = datetimeStr;
-          break;
-        case "date":
-          frontmatter[fieldName] = dateStr;
-          break;
-        case "string":
-          frontmatter[fieldName] = fieldDef.enum?.length ? fieldDef.enum[0] : "";
-          break;
-        case "number":
-          frontmatter[fieldName] = 0;
-          break;
-        case "boolean":
-          frontmatter[fieldName] = false;
-          break;
-      }
-    }
-  }
-  if (options.source && schema.fields.source) frontmatter.source = options.source;
-  if (options.sessionId && schema.fields.session_id) frontmatter.session_id = options.sessionId;
-  return frontmatter;
-}
-function validateFrontmatter(primitiveType, frontmatter) {
-  const schema = getSchema(primitiveType);
-  if (!schema) return { valid: true, errors: [] };
-  const errors = [];
-  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-    const value = frontmatter[fieldName];
-    if (fieldDef.required && (value === void 0 || value === null || value === "")) {
-      errors.push(`Missing required field: ${fieldName}`);
-      continue;
-    }
-    if (value === void 0 || value === null) continue;
-    if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
-      errors.push(`Invalid value for ${fieldName}: "${String(value)}". Must be one of: ${fieldDef.enum.join(", ")}`);
-    }
-    switch (fieldDef.type) {
-      case "number":
-        if (typeof value !== "number" && isNaN(Number(value))) {
-          errors.push(`Field ${fieldName} must be a number`);
-        }
-        break;
-      case "boolean":
-        if (typeof value !== "boolean" && value !== "true" && value !== "false") {
-          errors.push(`Field ${fieldName} must be a boolean`);
-        }
-        break;
-      case "datetime":
-        if (typeof value === "string" && isNaN(Date.parse(value))) {
-          errors.push(`Field ${fieldName} must be a valid datetime`);
-        }
-        break;
-      case "date":
-        if (typeof value === "string" && !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-          errors.push(`Field ${fieldName} must be a valid date (YYYY-MM-DD)`);
-        }
-        break;
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function serializeFrontmatter(frontmatter) {
-  const lines = ["---"];
-  for (const [key, value] of Object.entries(frontmatter)) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      lines.push(`${key}:`);
-      for (const item of value) {
-        lines.push(`  - ${String(item)}`);
-      }
-    } else if (typeof value === "object") {
-      lines.push(`${key}: ${JSON.stringify(value)}`);
-    } else if (typeof value === "string" && value.includes("\n")) {
-      lines.push(`${key}: |`);
-      for (const line of value.split("\n")) {
-        lines.push(`  ${line}`);
-      }
-    } else {
-      lines.push(`${key}: ${String(value)}`);
-    }
-  }
-  lines.push("---");
-  return lines.join("\n");
-}
-
-// src/plugin/noise-filter.ts
-var REFUSAL_PATTERNS = [
-  /\b(i can'?t help with|i'?m not able to|i cannot|i'?m unable to|as an ai|i don'?t have the ability)\b/i,
-  /\b(i'?m sorry,?\s+(?:but )?i|unfortunately,?\s+i (?:can'?t|cannot))\b/i,
-  /\b(that'?s (?:beyond|outside) my|i'?m not (?:designed|programmed) to)\b/i,
-  /\b(i (?:must |need to )?(?:decline|refuse)|i won'?t be able to)\b/i
-];
-var META_PATTERNS = [
-  /\b(how does it feel|what'?s it like being|are you (?:sentient|conscious|alive|real))\b/i,
-  /\b(do you have (?:feelings|emotions|consciousness|a soul))\b/i,
-  /\b(what are you|who made you|who created you|what model are you)\b/i,
-  /\b(can you think|do you dream|are you aware)\b/i
-];
-var GREETING_PATTERNS = [
-  /^(?:hi|hello|hey|howdy|greetings|good (?:morning|afternoon|evening)|what'?s up|sup|yo)\s*[!.?]?\s*$/i,
-  /^(?:thanks?|thank you|thx|ty|cheers)\s*[!.?]?\s*$/i,
-  /^(?:ok|okay|sure|got it|understood|perfect|great|cool|nice|awesome)\s*[!.?]?\s*$/i,
-  /^(?:bye|goodbye|see you|later|gn|good night|cya)\s*[!.?]?\s*$/i
-];
-var LOW_INFO_PATTERNS = [
-  /^[!?.]+$/,
-  // Just punctuation
-  /^[\p{Emoji}\s]+$/u,
-  // Emoji-only
-  /^(?:yes|no|maybe|idk|hmm|hm|ah|oh|uh|um|lol|lmao|haha|heh)\s*[!.?]*$/i
-];
-var SYSTEM_NOISE_PATTERNS = [
-  /^(?:\[System|HEARTBEAT|NO_REPLY)/,
-  /^<(?:relevant-memories|session-recap|user-preferences)/,
-  /^\s*\{[\s\S]*"(?:type|action|tool_use)"[\s\S]*\}\s*$/
-  // JSON tool calls
-];
-var DEFAULT_NOISE_CONFIG = {
-  enabled: true,
-  minLength: 15,
-  maxLength: 5e3
-};
-function isNoise(text, config = DEFAULT_NOISE_CONFIG) {
-  if (!config.enabled) return { isNoise: false };
-  if (!text) return { isNoise: true, category: "length", reason: "Empty text" };
-  const trimmed = text.trim();
-  if (trimmed.length < config.minLength) {
-    return { isNoise: true, category: "length", reason: `Too short (${trimmed.length} < ${config.minLength})` };
-  }
-  if (trimmed.length > config.maxLength) {
-    return { isNoise: true, category: "length", reason: `Too long (${trimmed.length} > ${config.maxLength})` };
-  }
-  for (const pattern of SYSTEM_NOISE_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { isNoise: true, category: "system", reason: "System noise" };
-    }
-  }
-  for (const pattern of GREETING_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { isNoise: true, category: "greeting", reason: "Greeting/acknowledgment" };
-    }
-  }
-  for (const pattern of LOW_INFO_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { isNoise: true, category: "low_info", reason: "Low information content" };
-    }
-  }
-  for (const pattern of REFUSAL_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { isNoise: true, category: "refusal", reason: "AI refusal" };
-    }
-  }
-  for (const pattern of META_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { isNoise: true, category: "meta", reason: "Meta-question about AI" };
-    }
-  }
-  const markdownChars = (trimmed.match(/[#*`\-|>]/g) || []).length;
-  if (markdownChars / trimmed.length > 0.15) {
-    return { isNoise: true, category: "system", reason: "High markdown density (likely code/formatting)" };
-  }
-  return { isNoise: false };
-}
-
-// src/plugin/observe.ts
-function isObservable(text, noiseConfig) {
-  if (!text || text.length < 20 || text.length > 5e3) return false;
-  const check = isNoise(text, noiseConfig ?? DEFAULT_NOISE_CONFIG);
-  return !check.isNoise;
-}
-var OBSERVATION_PATTERNS = [
-  // Preferences
-  { pattern: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, weight: 2 },
-  // Decisions
-  { pattern: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it|go with)\b/i, weight: 2 },
-  // Facts about people/things
-  { pattern: /\b(my .+ is|his .+ is|her .+ is|their .+ is|works at|lives in|born in)\b/i, weight: 1.5 },
-  // Contact info
-  { pattern: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/i, weight: 2 },
-  // Explicit memory request
-  { pattern: /\b(remember|don't forget|keep in mind|note that|important:)\b/i, weight: 2.5 },
-  // Deadlines/dates
-  { pattern: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, weight: 1.5 },
-  // Lessons learned
-  { pattern: /\b(i learned|we learned|lesson|realized|discovered|found out)\b/i, weight: 1.5 },
-  // Tasks
-  { pattern: /\b(need to|should|must|have to|todo|task)\b/i, weight: 1 },
-  // Projects
-  { pattern: /\b(working on|building|developing|project|initiative)\b/i, weight: 1 }
-];
-function extractObservations(text) {
-  const observations = [];
-  const sentences = splitIntoSentences(text);
-  const now = /* @__PURE__ */ new Date();
-  for (const sentence of sentences) {
-    if (sentence.length < 15) continue;
-    let totalWeight = 0;
-    for (const { pattern, weight } of OBSERVATION_PATTERNS) {
-      if (pattern.test(sentence)) {
-        totalWeight += weight;
-      }
-    }
-    if (totalWeight < 1) continue;
-    const classification = classifyText(sentence);
-    const category = deriveCategoryFromPrimitive(classification.primitiveType, sentence);
-    const tags = generateTags(classification, sentence);
-    observations.push({
-      text: sentence.trim(),
-      primitiveType: classification.primitiveType,
-      confidence: classification.confidence,
-      matchedKeywords: classification.matchedKeywords,
-      category,
-      tags,
-      extractedAt: now
-    });
-  }
-  return observations;
-}
-function splitIntoSentences(text) {
-  const raw = text.split(/(?<=[.!?\n])\s+/);
-  return raw.map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function deriveCategoryFromPrimitive(primitiveType, text) {
-  const lower = text.toLowerCase();
-  if (primitiveType === "memory_event") {
-    if (/prefer|like|love|hate|want|need|always|never/i.test(lower)) return "preference";
-    if (/remember|don't forget|keep in mind|note that/i.test(lower)) return "note";
-    return "fact";
-  }
-  const categoryMap = {
-    person: "entity",
-    decision: "decision",
-    task: "task",
-    project: "project",
-    lesson: "lesson",
-    trigger: "automation",
-    run: "execution",
-    checkpoint: "checkpoint",
-    handoff: "handoff",
-    "daily-note": "daily",
-    daily: "daily",
-    party: "entity",
-    workspace: "workspace"
-  };
-  return categoryMap[primitiveType] ?? "fact";
-}
-function generateTags(classification, text) {
-  const tags = [classification.primitiveType];
-  const lower = text.toLowerCase();
-  if (/prefer|like|love/i.test(lower)) tags.push("positive");
-  if (/hate|dislike|don't like/i.test(lower)) tags.push("negative");
-  if (/deadline|due|by tomorrow|by tonight/i.test(lower)) tags.push("time-sensitive");
-  if (/important|critical|urgent/i.test(lower)) tags.push("high-priority");
-  if (/email|phone|contact/i.test(lower)) tags.push("contact-info");
-  if (/decided|chose|approved/i.test(lower)) tags.push("finalized");
-  if (/proposed|considering|might/i.test(lower)) tags.push("tentative");
-  return [...new Set(tags)];
-}
-function processMessageForObservations(content, _options = {}) {
-  if (!isObservable(content)) {
-    return {
-      observations: [],
-      skipped: 1,
-      reason: "Content not observable"
-    };
-  }
-  const observations = extractObservations(content);
-  const maxObservations = 5;
-  const limited = observations.slice(0, maxObservations);
-  const skipped = observations.length - limited.length;
-  return {
-    observations: limited,
-    skipped,
-    reason: skipped > 0 ? `Limited to ${maxObservations} observations` : void 0
-  };
-}
-function detectCategory(text) {
-  const classification = classifyText(text);
-  return deriveCategoryFromPrimitive(classification.primitiveType, text);
-}
-function extractSearchTerms(input) {
-  const noise = /\b(hey|hi|hello|um|uh|like|just|so|well|you know|i mean|basically|actually|really|very|pretty|quite|how does it feel|how do you|can you|could you|would you|do you|what do you think|tell me about)\b/gi;
-  let cleaned = input.replace(noise, " ").replace(/\s+/g, " ").trim();
-  if (cleaned.length < 5) cleaned = input.trim();
-  return cleaned;
-}
-
-// src/plugin/inject.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync } from "fs";
-import { join as join2, relative } from "path";
-function parseYamlFrontmatter2(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  try {
-    const frontmatter = parseSimpleYaml2(match[1]);
-    return { frontmatter, body: match[2] };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleYaml2(yaml) {
-  const result = {};
-  for (const line of yaml.split("\n")) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = line.slice(0, colonIndex).trim();
-    const valueStr = line.slice(colonIndex + 1).trim();
-    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
-    result[key] = parseYamlValue2(valueStr);
-  }
-  return result;
-}
-function parseYamlValue2(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function scanVaultFiles(vaultPath, options = {}) {
-  const files = [];
-  const maxAge = options.maxAge ?? 7 * 24 * 60 * 60 * 1e3;
-  const limit = options.limit ?? 100;
-  const now = Date.now();
-  const cutoff = now - maxAge;
-  const dirsToScan = findVaultDirectories(vaultPath);
-  for (const dir of dirsToScan) {
-    if (!existsSync2(dir)) continue;
-    try {
-      scanDirectory(dir, vaultPath, files, cutoff, options.primitiveTypes);
-    } catch {
-    }
-  }
-  files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
-  return files.slice(0, limit);
-}
-function findVaultDirectories(vaultPath) {
-  const dirs = [vaultPath];
-  const commonDirs = [
-    "tasks",
-    "projects",
-    "decisions",
-    "people",
-    "persons",
-    "notes",
-    "daily",
-    "journal",
-    "ledger",
-    "memory",
-    "memories",
-    "observations",
-    "lessons",
-    "triggers",
-    "runs",
-    "checkpoints",
-    "handoffs",
-    "workspaces",
-    "parties"
-  ];
-  for (const subdir of commonDirs) {
-    const fullPath = join2(vaultPath, subdir);
-    if (existsSync2(fullPath)) dirs.push(fullPath);
-  }
-  try {
-    const entries = readdirSync2(vaultPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-        const fullPath = join2(vaultPath, entry.name);
-        if (!dirs.includes(fullPath)) dirs.push(fullPath);
-      }
-    }
-  } catch {
-  }
-  return dirs;
-}
-function scanDirectory(dir, vaultPath, files, cutoff, primitiveTypes) {
-  const entries = readdirSync2(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      const depth = fullPath.replace(vaultPath, "").split("/").length;
-      if (depth <= 3) {
-        scanDirectory(fullPath, vaultPath, files, cutoff, primitiveTypes);
-      }
-    } else if (entry.name.endsWith(".md")) {
-      try {
-        const stat = statSync(fullPath);
-        if (stat.mtimeMs < cutoff) continue;
-        const content = readFileSync2(fullPath, "utf-8");
-        const parsed = parseYamlFrontmatter2(content);
-        if (!parsed) continue;
-        const primitiveType = detectPrimitiveType(parsed.frontmatter, fullPath);
-        if (primitiveTypes && !primitiveTypes.includes(primitiveType)) continue;
-        files.push({
-          path: fullPath,
-          relativePath: relative(vaultPath, fullPath),
-          primitiveType,
-          frontmatter: parsed.frontmatter,
-          content: parsed.body,
-          modifiedAt: stat.mtime,
-          createdAt: stat.birthtime
-        });
-      } catch {
-      }
-    }
-  }
-}
-function detectPrimitiveType(frontmatter, filePath) {
-  if (frontmatter.primitive) return String(frontmatter.primitive);
-  if (frontmatter.type) return String(frontmatter.type);
-  const pathLower = filePath.toLowerCase();
-  const pathMap = {
-    "/tasks/": "task",
-    "/projects/": "project",
-    "/decisions/": "decision",
-    "/people/": "person",
-    "/persons/": "person",
-    "/daily/": "daily-note",
-    "/journal/": "daily-note",
-    "/lessons/": "lesson",
-    "/triggers/": "trigger",
-    "/runs/": "run",
-    "/checkpoints/": "checkpoint",
-    "/handoffs/": "handoff",
-    "/ledger/": "memory_event",
-    "/memory/": "memory_event",
-    "/memories/": "memory_event"
-  };
-  for (const [segment, type] of Object.entries(pathMap)) {
-    if (pathLower.includes(segment)) return type;
-  }
-  return "unknown";
-}
-function buildSessionRecap(vaultPath, options = {}) {
-  const maxAge = options.maxAge ?? 24 * 60 * 60 * 1e3;
-  const limit = options.limit ?? 20;
-  const includeContent = options.includeContent ?? false;
-  const files = scanVaultFiles(vaultPath, { maxAge, limit });
-  if (files.length === 0) {
-    return { xml: "", fileCount: 0, primitiveGroups: {}, timeRange: null };
-  }
-  const groups = {};
-  for (const file of files) {
-    const type = file.primitiveType;
-    if (!groups[type]) groups[type] = [];
-    groups[type].push(file);
-  }
-  const lines = ["<session-recap>"];
-  lines.push(`<summary>Found ${files.length} recent items across ${Object.keys(groups).length} categories</summary>`);
-  for (const [primitiveType, groupFiles] of Object.entries(groups)) {
-    lines.push(`<${primitiveType}-items count="${groupFiles.length}">`);
-    for (const file of groupFiles.slice(0, 5)) {
-      const title = file.frontmatter.title || file.frontmatter.summary || file.relativePath;
-      const status = file.frontmatter.status || "";
-      const modified = file.modifiedAt.toISOString().slice(0, 16).replace("T", " ");
-      lines.push(`  <item path="${file.relativePath}" modified="${modified}"${status ? ` status="${String(status)}"` : ""}>`);
-      lines.push(`    <title>${escapeXml(String(title))}</title>`);
-      if (includeContent && file.content) {
-        const snippet = file.content.slice(0, 200).replace(/\n/g, " ").trim();
-        if (snippet) {
-          lines.push(`    <snippet>${escapeXml(snippet)}</snippet>`);
-        }
-      }
-      lines.push("  </item>");
-    }
-    if (groupFiles.length > 5) {
-      lines.push(`  <more count="${groupFiles.length - 5}" />`);
-    }
-    lines.push(`</${primitiveType}-items>`);
-  }
-  lines.push("</session-recap>");
-  const sortedByTime = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
-  const timeRange = {
-    oldest: sortedByTime[0].modifiedAt,
-    newest: sortedByTime[sortedByTime.length - 1].modifiedAt
-  };
-  const primitiveGroups = {};
-  for (const [type, groupFiles] of Object.entries(groups)) {
-    primitiveGroups[type] = groupFiles.length;
-  }
-  return { xml: lines.join("\n"), fileCount: files.length, primitiveGroups, timeRange };
-}
-function buildPreferenceContext(vaultPath, options = {}) {
-  const maxAge = options.maxAge ?? 30 * 24 * 60 * 60 * 1e3;
-  const limit = options.limit ?? 50;
-  const files = scanVaultFiles(vaultPath, { maxAge, limit: limit * 2 });
-  const preferenceFiles = files.filter((file) => {
-    if (file.frontmatter.type === "preference") return true;
-    if (file.primitiveType === "memory_event" && file.frontmatter.type === "preference") return true;
-    const content = (file.content || "").toLowerCase();
-    return /\b(prefer|like|love|hate|dislike|want|need|always|never)\b/.test(content);
-  }).slice(0, limit);
-  if (preferenceFiles.length === 0) {
-    return { xml: "", preferenceCount: 0, categories: [] };
-  }
-  const categories = /* @__PURE__ */ new Set();
-  for (const file of preferenceFiles) {
-    if (file.frontmatter.category) categories.add(String(file.frontmatter.category));
-  }
-  const lines = ["<user-preferences>"];
-  for (const file of preferenceFiles) {
-    const summary = file.frontmatter.summary || file.frontmatter.title || extractPreferenceSummary(file.content);
-    if (!summary) continue;
-    const category = file.frontmatter.category || "general";
-    const sentiment = file.frontmatter.sentiment || inferSentiment(file.content);
-    lines.push(`  <preference category="${escapeXml(String(category))}" sentiment="${String(sentiment)}">`);
-    lines.push(`    ${escapeXml(String(summary))}`);
-    lines.push("  </preference>");
-  }
-  lines.push("</user-preferences>");
-  return {
-    xml: lines.join("\n"),
-    preferenceCount: preferenceFiles.length,
-    categories: Array.from(categories)
-  };
-}
-function extractPreferenceSummary(content) {
-  if (!content) return "";
-  const sentences = content.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10);
-  for (const sentence of sentences) {
-    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/i.test(sentence)) {
-      return sentence.slice(0, 150);
-    }
-  }
-  return sentences[0]?.slice(0, 150) || "";
-}
-function inferSentiment(content) {
-  if (!content) return "neutral";
-  const lower = content.toLowerCase();
-  if (/\b(love|like|prefer|enjoy|want|need|always)\b/.test(lower)) return "positive";
-  if (/\b(hate|dislike|don't like|never|avoid)\b/.test(lower)) return "negative";
-  return "neutral";
-}
-function formatMemoriesForContext(results, collection) {
-  if (results.length === 0) return "";
-  const lines = results.map((r, i) => {
-    const file = (r.file || "").replace(`qmd://${collection}/`, "");
-    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "";
-    return `${i + 1}. [${file}] ${snippet}`;
-  });
-  return `<relevant-memories>
-These are recalled from long-term vault memory. Treat as historical context.
-${lines.join("\n")}
-</relevant-memories>`;
-}
-function formatSearchResults(results, collection) {
-  if (results.length === 0) return "No relevant memories found.";
-  return results.map((r, i) => {
-    const file = (r.file || "").replace(`qmd://${collection}/`, "");
-    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
-    const score = ((r.score ?? 0) * 100).toFixed(0);
-    return `${i + 1}. [${file}] ${snippet} (${score}%)`;
-  }).join("\n");
-}
-function buildFullContext(vaultPath, options = {}) {
-  const parts = [];
-  if (options.includeRecap !== false) {
-    const recap = buildSessionRecap(vaultPath, {
-      maxAge: options.recapMaxAge ?? 24 * 60 * 60 * 1e3,
-      limit: 15,
-      includeContent: true
-    });
-    if (recap.xml) parts.push(recap.xml);
-  }
-  if (options.includePreferences !== false) {
-    const prefs = buildPreferenceContext(vaultPath, {
-      maxAge: options.preferenceMaxAge ?? 30 * 24 * 60 * 60 * 1e3,
-      limit: 20
-    });
-    if (prefs.xml) parts.push(prefs.xml);
-  }
-  return parts.join("\n\n");
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-
-// src/plugin/vault.ts
-import { existsSync as existsSync3, mkdirSync, writeFileSync, readFileSync as readFileSync3, appendFileSync } from "fs";
-import { join as join3 } from "path";
-var autoEmbedFn = null;
-function setAutoEmbedFn(fn) {
-  autoEmbedFn = fn;
-}
-async function autoEmbed(filePath, content) {
-  if (autoEmbedFn) {
-    await autoEmbedFn(filePath, content).catch(() => {
-    });
-  }
-}
-function writeVaultFile(vaultPath, options) {
-  const errors = [];
-  const primitiveType = options.primitiveType ?? classifyText(options.content ?? options.title ?? "").primitiveType;
-  const schema = getSchema(primitiveType);
-  const frontmatter = generateFrontmatter(primitiveType, {
-    title: options.title,
-    extraFields: options.extraFields,
-    source: options.source,
-    sessionId: options.sessionId
-  });
-  const validation = validateFrontmatter(primitiveType, frontmatter);
-  if (!validation.valid) errors.push(...validation.errors);
-  const directory = options.directory ?? getDefaultDirectory(vaultPath, primitiveType);
-  if (!existsSync3(directory)) {
-    mkdirSync(directory, { recursive: true });
-  }
-  const filename = options.filename ?? generateFilename(primitiveType, options.title, frontmatter);
-  const filePath = join3(directory, filename);
-  const fileExists = existsSync3(filePath);
-  if (fileExists && !options.overwrite) {
-    return updateVaultFile(filePath, frontmatter, options.content, primitiveType, errors);
-  }
-  const fileContent = buildFileContent(frontmatter, options.content, schema);
-  try {
-    writeFileSync(filePath, fileContent, "utf-8");
-    autoEmbed(filePath, fileContent).catch(() => {
-    });
-    return {
-      success: errors.length === 0,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: true,
-      updated: false
-    };
-  } catch (err) {
-    errors.push(`Failed to write file: ${String(err)}`);
-    return {
-      success: false,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: false
-    };
-  }
-}
-function updateVaultFile(filePath, newFrontmatter, newContent, primitiveType, errors) {
-  try {
-    const existingContent = readFileSync3(filePath, "utf-8");
-    const parsed = parseExistingFile(existingContent);
-    if (!parsed) {
-      errors.push("Failed to parse existing file");
-      return { success: false, path: filePath, primitiveType, errors, created: false, updated: false };
-    }
-    const mergedFrontmatter = {
-      ...parsed.frontmatter,
-      ...newFrontmatter,
-      updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (parsed.frontmatter.created) {
-      mergedFrontmatter.created = parsed.frontmatter.created;
-    }
-    const content = newContent ?? parsed.body;
-    const schema = getSchema(primitiveType);
-    const fileContent = buildFileContent(mergedFrontmatter, content, schema);
-    writeFileSync(filePath, fileContent, "utf-8");
-    return {
-      success: errors.length === 0,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: true
-    };
-  } catch (err) {
-    errors.push(`Failed to update file: ${String(err)}`);
-    return { success: false, path: filePath, primitiveType, errors, created: false, updated: false };
-  }
-}
-function parseExistingFile(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  try {
-    const result = {};
-    for (const line of match[1].split("\n")) {
-      if (!line.trim() || line.trim().startsWith("#")) continue;
-      const colonIndex = line.indexOf(":");
-      if (colonIndex === -1) continue;
-      const key = line.slice(0, colonIndex).trim();
-      const valueStr = line.slice(colonIndex + 1).trim();
-      if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
-      result[key] = parseSimpleValue(valueStr);
-    }
-    return { frontmatter: result, body: match[2] };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleValue(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function getDefaultDirectory(vaultPath, primitiveType) {
-  const directoryMap = {
-    task: "tasks",
-    project: "projects",
-    decision: "decisions",
-    person: "people",
-    lesson: "lessons",
-    trigger: "triggers",
-    run: "runs",
-    checkpoint: "checkpoints",
-    handoff: "handoffs",
-    "daily-note": "daily",
-    daily: "daily",
-    party: "parties",
-    workspace: "workspaces",
-    memory_event: "memory"
-  };
-  const subdir = directoryMap[primitiveType] ?? "notes";
-  return join3(vaultPath, subdir);
-}
-function generateFilename(primitiveType, title, _frontmatter) {
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().split("T")[0];
-  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "");
-  if (title) {
-    const slug = slugify(title);
-    return `${dateStr}-${slug}.md`;
-  }
-  switch (primitiveType) {
-    case "daily-note":
-    case "daily":
-      return `${dateStr}.md`;
-    case "memory_event":
-      return `${dateStr}-${timeStr}.md`;
-    case "run":
-      return `run-${dateStr}-${timeStr}.md`;
-    case "checkpoint":
-      return `checkpoint-${dateStr}-${timeStr}.md`;
-    case "handoff":
-      return `handoff-${dateStr}-${timeStr}.md`;
-    default:
-      return `${primitiveType}-${dateStr}-${timeStr}.md`;
-  }
-}
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
-function buildFileContent(frontmatter, content, schema) {
-  const parts = [];
-  parts.push(serializeFrontmatter(frontmatter));
-  parts.push("");
-  const title = frontmatter.title || frontmatter.summary;
-  if (title) {
-    parts.push(`# ${String(title)}`);
-    parts.push("");
-  }
-  if (content) {
-    parts.push(content);
-  } else if (schema?.bodyTemplate) {
-    let body = schema.bodyTemplate;
-    body = body.replace(/\{\{title\}\}/g, String(title || "Untitled"));
-    body = body.replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    body = body.replace(/\{\{datetime\}\}/g, (/* @__PURE__ */ new Date()).toISOString());
-    body = body.replace(/\{\{links_line\}\}/g, "");
-    body = body.replace(/\{\{content\}\}/g, "");
-    parts.push(body.trim());
-  }
-  return parts.join("\n");
-}
-function writeObservation(vaultPath, observation, options = {}) {
-  const extraFields = {
-    type: observation.primitiveType === "memory_event" ? observation.category : observation.primitiveType,
-    confidence: observation.confidence,
-    tags: observation.tags,
-    observed_at: observation.extractedAt.toISOString()
-  };
-  if (options.scope && options.scope !== "global") {
-    extraFields.scope = options.scope;
-  }
-  return writeVaultFile(vaultPath, {
-    primitiveType: observation.primitiveType,
-    title: observation.text.slice(0, 80),
-    content: observation.text,
-    extraFields,
-    source: options.source ?? "openclaw",
-    sessionId: options.sessionId
-  });
-}
-function appendToLedger(vaultPath, entry) {
-  const dateStr = entry.timestamp.toISOString().slice(0, 10);
-  const ledgerDir = join3(vaultPath, "ledger");
-  if (!existsSync3(ledgerDir)) {
-    mkdirSync(ledgerDir, { recursive: true });
-  }
-  const ledgerFile = join3(ledgerDir, `${dateStr}.md`);
-  const timeStr = entry.timestamp.toISOString().slice(11, 19);
-  const parts = [`[${timeStr}]`];
-  if (entry.category) parts.push(`[${entry.category}]`);
-  if (entry.actor) parts.push(`(${entry.actor})`);
-  parts.push(entry.content);
-  const line = `
-- ${parts.join(" ")}`;
-  if (!existsSync3(ledgerFile)) {
-    const frontmatter = serializeFrontmatter({
-      type: "ledger",
-      date: dateStr,
-      created: entry.timestamp.toISOString()
-    });
-    writeFileSync(ledgerFile, `${frontmatter}
-
-# Observation Ledger \u2014 ${dateStr}
-${line}`, "utf-8");
-  } else {
-    appendFileSync(ledgerFile, line, "utf-8");
-  }
-}
-function appendObservationToLedger(vaultPath, observation, actor) {
-  appendToLedger(vaultPath, {
-    timestamp: observation.extractedAt,
-    category: observation.category,
-    actor,
-    content: observation.text,
-    primitiveType: observation.primitiveType,
-    tags: observation.tags
-  });
-}
-function batchWriteObservations(vaultPath, observations, options = {}) {
-  const results = [];
-  let successful = 0;
-  let failed = 0;
-  const writeLedger = options.writeLedger ?? true;
-  const writeFiles = options.writeFiles ?? false;
-  for (const observation of observations) {
-    if (writeLedger) {
-      try {
-        appendObservationToLedger(vaultPath, observation, options.actor);
-      } catch {
-      }
-    }
-    if (writeFiles) {
-      const result = writeObservation(vaultPath, observation, {
-        source: options.source,
-        sessionId: options.sessionId
-      });
-      results.push(result);
-      if (result.success) successful++;
-      else failed++;
-    } else {
-      successful++;
-      results.push({
-        success: true,
-        path: join3(vaultPath, "ledger", `${observation.extractedAt.toISOString().slice(0, 10)}.md`),
-        primitiveType: observation.primitiveType,
-        errors: [],
-        created: false,
-        updated: true
-      });
-    }
-  }
-  return { total: observations.length, successful, failed, results };
-}
-function ensureVaultStructure(vaultPath) {
-  const directories = [
-    "tasks",
-    "projects",
-    "decisions",
-    "people",
-    "lessons",
-    "memory",
-    "ledger",
-    "daily"
-  ];
-  for (const dir of directories) {
-    const fullPath = join3(vaultPath, dir);
-    if (!existsSync3(fullPath)) {
-      mkdirSync(fullPath, { recursive: true });
-    }
-  }
-}
-
-// src/plugin/retrieval.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join4, relative as relative2 } from "path";
-
-// src/plugin/types.ts
-function parseScope(scope) {
-  if (scope === "global") return "global";
-  if (scope.startsWith("agent:") || scope.startsWith("project:") || scope.startsWith("user:")) {
-    return scope;
-  }
-  return "global";
-}
-function matchesScope(itemScope, filterScope) {
-  if (filterScope === "global") return true;
-  return itemScope === filterScope;
-}
-var DEFAULT_RETRIEVAL_CONFIG = {
-  bm25Weight: 0.5,
-  semanticWeight: 0.5,
-  rrfK: 60,
-  topK: 10,
-  minScore: 0.01,
-  recencyHalfLifeDays: 14,
-  recencyWeight: 0.1,
-  decayHalfLifeDays: 60,
-  lengthNormAnchor: 500,
-  mmrLambda: 0.7,
-  rerankWeight: 0.6
-};
-
-// src/plugin/retrieval.ts
-function tokenize(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1);
-}
-function bm25Search(query, documents, topK) {
-  const queryTerms = tokenize(query);
-  if (queryTerms.length === 0 || documents.length === 0) return [];
-  const k1 = 1.2;
-  const b = 0.75;
-  const N = documents.length;
-  const docTokens = documents.map((d) => tokenize(`${d.title} ${d.content}`));
-  const avgDl = docTokens.reduce((sum, t) => sum + t.length, 0) / N;
-  const df = /* @__PURE__ */ new Map();
-  for (const term of queryTerms) {
-    let count = 0;
-    for (const tokens of docTokens) {
-      if (tokens.includes(term)) count++;
-    }
-    df.set(term, count);
-  }
-  const results = [];
-  for (let i = 0; i < documents.length; i++) {
-    const doc = documents[i];
-    const tokens = docTokens[i];
-    const dl = tokens.length;
-    let score = 0;
-    const tf = /* @__PURE__ */ new Map();
-    for (const t of tokens) {
-      tf.set(t, (tf.get(t) || 0) + 1);
-    }
-    for (const term of queryTerms) {
-      const termFreq = tf.get(term) || 0;
-      if (termFreq === 0) continue;
-      const docFreq = df.get(term) || 0;
-      const idf = Math.log((N - docFreq + 0.5) / (docFreq + 0.5) + 1);
-      const tfNorm = termFreq * (k1 + 1) / (termFreq + k1 * (1 - b + b * dl / avgDl));
-      score += idf * tfNorm;
-    }
-    if (score > 0) {
-      results.push({ id: doc.id, score, doc });
-    }
-  }
-  results.sort((a, b2) => b2.score - a.score);
-  return results.slice(0, topK);
-}
-var embeddingPipeline = null;
-var pipelineLoading = null;
-async function getEmbeddingPipeline() {
-  if (embeddingPipeline) return embeddingPipeline;
-  if (pipelineLoading) return pipelineLoading;
-  pipelineLoading = (async () => {
-    const { pipeline } = await import("@huggingface/transformers");
-    embeddingPipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
-      dtype: "fp32"
-    });
-    return embeddingPipeline;
-  })();
-  return pipelineLoading;
-}
-async function embed(text) {
-  const pipe = await getEmbeddingPipeline();
-  const result = await pipe(
-    text,
-    { pooling: "mean", normalize: true }
-  );
-  return new Float32Array(result.data);
-}
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  for (let i = 0; i < a.length; i++) {
-    dot += a[i] * b[i];
-  }
-  return dot;
-}
-function loadEmbeddingCache(vaultPath) {
-  const cachePath = join4(vaultPath, ".clawvault", "embeddings.bin.json");
-  const cache = /* @__PURE__ */ new Map();
-  if (!existsSync4(cachePath)) return cache;
-  try {
-    const data = JSON.parse(readFileSync4(cachePath, "utf-8"));
-    for (const [key, arr] of Object.entries(data)) {
-      cache.set(key, new Float32Array(arr));
-    }
-  } catch {
-  }
-  return cache;
-}
-async function semanticSearch(query, cache, topK) {
-  if (cache.size === 0) return [];
-  const queryEmb = await embed(query);
-  const results = [];
-  for (const [id, docEmb] of cache.entries()) {
-    results.push({ id, score: cosineSimilarity(queryEmb, docEmb) });
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results.slice(0, topK);
-}
-function reciprocalRankFusion(list1, list2, k = 60, weight1 = 0.5, weight2 = 0.5) {
-  const scores = /* @__PURE__ */ new Map();
-  for (let rank = 0; rank < list1.length; rank++) {
-    const { id } = list1[rank];
-    scores.set(id, (scores.get(id) || 0) + weight1 / (k + rank + 1));
-  }
-  for (let rank = 0; rank < list2.length; rank++) {
-    const { id } = list2[rank];
-    scores.set(id, (scores.get(id) || 0) + weight2 / (k + rank + 1));
-  }
-  return Array.from(scores.entries()).map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score);
-}
-async function crossEncoderRerank(query, documents, config) {
-  if (!config.rerankProvider || !config.rerankApiKey) return null;
-  if (documents.length === 0) return null;
-  const endpoints = {
-    jina: "https://api.jina.ai/v1/rerank",
-    voyage: "https://api.voyageai.com/v1/rerank",
-    siliconflow: "https://api.siliconflow.cn/v1/rerank",
-    pinecone: "https://api.pinecone.io/rerank"
-  };
-  const models = {
-    jina: "jina-reranker-v2-base-multilingual",
-    voyage: "rerank-2",
-    siliconflow: "BAAI/bge-reranker-v2-m3",
-    pinecone: "bge-reranker-v2-m3"
-  };
-  const endpoint = config.rerankEndpoint || endpoints[config.rerankProvider];
-  const model = config.rerankModel || models[config.rerankProvider];
-  if (!endpoint) return null;
-  try {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${config.rerankApiKey}`
-      },
-      body: JSON.stringify({
-        model,
-        query,
-        documents,
-        top_n: documents.length
-      }),
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!response.ok) return null;
-    const data = await response.json();
-    if (!data.results) return null;
-    const scores = new Array(documents.length).fill(0);
-    for (const result of data.results) {
-      if (result.index >= 0 && result.index < documents.length) {
-        scores[result.index] = result.relevance_score;
-      }
-    }
-    return scores;
-  } catch {
-    return null;
-  }
-}
-function computeRecencyBoost(modifiedAt, now, halfLifeDays, weight) {
-  if (halfLifeDays <= 0 || weight <= 0) return 0;
-  const ageDays = (now.getTime() - modifiedAt.getTime()) / (1e3 * 60 * 60 * 24);
-  const decay = Math.exp(-ageDays * Math.LN2 / halfLifeDays);
-  return weight * decay;
-}
-function computeTimeDecay(modifiedAt, now, halfLifeDays) {
-  if (halfLifeDays <= 0) return 1;
-  const ageDays = (now.getTime() - modifiedAt.getTime()) / (1e3 * 60 * 60 * 24);
-  return 0.5 + 0.5 * Math.exp(-ageDays / halfLifeDays);
-}
-function computeLengthNorm(charLen, anchor) {
-  if (anchor <= 0 || charLen <= 0) return 1;
-  return 1 / (1 + Math.log2(Math.max(1, charLen / anchor)));
-}
-function mmrRerank(results, embeddingCache, lambda, topK) {
-  if (lambda >= 1 || results.length <= 1) return results.slice(0, topK);
-  const selected = [];
-  const remaining = new Set(results.map((_, i) => i));
-  selected.push(results[0]);
-  remaining.delete(0);
-  while (selected.length < topK && remaining.size > 0) {
-    let bestIdx = -1;
-    let bestMmrScore = -Infinity;
-    for (const idx of remaining) {
-      const relevance = results[idx].fusedScore;
-      let maxSim = 0;
-      const candidateId = results[idx].file?.replace(/^qmd:\/\/[^/]+\//, "").replace(/\.md$/, "") || "";
-      const candidateEmb = embeddingCache.get(candidateId);
-      if (candidateEmb) {
-        for (const sel of selected) {
-          const selId = sel.file?.replace(/^qmd:\/\/[^/]+\//, "").replace(/\.md$/, "") || "";
-          const selEmb = embeddingCache.get(selId);
-          if (selEmb) {
-            maxSim = Math.max(maxSim, cosineSimilarity(candidateEmb, selEmb));
-          }
-        }
-      }
-      const mmrScore = lambda * relevance - (1 - lambda) * maxSim;
-      if (mmrScore > bestMmrScore) {
-        bestMmrScore = mmrScore;
-        bestIdx = idx;
-      }
-    }
-    if (bestIdx >= 0) {
-      selected.push(results[bestIdx]);
-      remaining.delete(bestIdx);
-    } else {
-      break;
-    }
-  }
-  return selected;
-}
-function loadVaultDocuments(vaultPath) {
-  const documents = [];
-  const dirsToScan = [
-    "tasks",
-    "projects",
-    "decisions",
-    "people",
-    "persons",
-    "notes",
-    "daily",
-    "journal",
-    "ledger",
-    "memory",
-    "memories",
-    "observations",
-    "lessons"
-  ];
-  const scanDir = (dir) => {
-    if (!existsSync4(dir)) return;
-    try {
-      const entries = readdirSync3(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-        const fullPath = join4(dir, entry.name);
-        if (entry.isDirectory()) {
-          const depth = fullPath.replace(vaultPath, "").split("/").length;
-          if (depth <= 3) scanDir(fullPath);
-        } else if (entry.name.endsWith(".md")) {
-          try {
-            const stat = statSync2(fullPath);
-            const content = readFileSync4(fullPath, "utf-8");
-            const parsed = parseYamlFrontmatter(content);
-            const relPath = relative2(vaultPath, fullPath);
-            const docId = relPath.replace(/\.md$/, "");
-            const title = parsed?.frontmatter?.title || parsed?.frontmatter?.summary || entry.name.replace(/\.md$/, "");
-            const body = parsed?.body || content;
-            const scope = parseScope(String(parsed?.frontmatter?.scope || "global"));
-            documents.push({
-              id: docId,
-              file: relPath,
-              title: String(title),
-              content: body.slice(0, 2e3),
-              modifiedAt: stat.mtime,
-              scope
-            });
-          } catch {
-          }
-        }
-      }
-    } catch {
-    }
-  };
-  scanDir(vaultPath);
-  for (const subdir of dirsToScan) {
-    const fullPath = join4(vaultPath, subdir);
-    if (existsSync4(fullPath) && !documents.some((d) => d.file.startsWith(subdir + "/"))) {
-      scanDir(fullPath);
-    }
-  }
-  return documents;
-}
-function qmdSearch(query, collection, limit) {
-  const sanitized = query.replace(/['']/g, " ").replace(/[^\w\s\-.,?!]/g, " ").trim();
-  if (!sanitized) return [];
-  let results = [];
-  for (const cmd of ["query", "search"]) {
-    try {
-      const result = execFileSync("qmd", [
-        cmd,
-        sanitized,
-        "-n",
-        String(Math.max(limit * 2, 20)),
-        "--json",
-        "-c",
-        collection
-      ], {
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-        maxBuffer: 10 * 1024 * 1024,
-        timeout: cmd === "query" ? 3e4 : 15e3
-      });
-      const parsed = JSON.parse(result);
-      if (Array.isArray(parsed) && parsed.length > 0) {
-        results = parsed;
-        break;
-      }
-    } catch (err) {
-      const errObj = err;
-      if (errObj.stdout) {
-        try {
-          const parsed = JSON.parse(errObj.stdout);
-          if (Array.isArray(parsed) && parsed.length > 0) {
-            results = parsed;
-            break;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  return results;
-}
-async function retrieve(query, options) {
-  const config = { ...DEFAULT_RETRIEVAL_CONFIG, ...options.config };
-  const { vaultPath, collection = "clawvault" } = options;
-  const scope = options.scope || "global";
-  const now = /* @__PURE__ */ new Date();
-  let fusedResults = [];
-  let usedInProcess = false;
-  try {
-    const documents = loadVaultDocuments(vaultPath);
-    const embeddingCache = loadEmbeddingCache(vaultPath);
-    const scopedDocs = scope === "global" ? documents : documents.filter((d) => matchesScope(d.scope, scope));
-    if (scopedDocs.length > 0) {
-      const bm25Results = bm25Search(query, scopedDocs, config.topK * 3);
-      const bm25Ranked = bm25Results.map((r) => ({ id: r.id, score: r.score }));
-      const semanticRanked = await semanticSearch(query, embeddingCache, config.topK * 3);
-      fusedResults = reciprocalRankFusion(
-        bm25Ranked,
-        semanticRanked,
-        config.rrfK,
-        config.bm25Weight,
-        config.semanticWeight
-      ).map((r) => {
-        const doc = scopedDocs.find((d) => d.id === r.id);
-        return { ...r, doc };
-      });
-      usedInProcess = true;
-    }
-  } catch {
-  }
-  if (!usedInProcess || fusedResults.length === 0) {
-    const qmdResults = qmdSearch(query, collection, config.topK * 2);
-    fusedResults = qmdResults.map((r, i) => ({
-      id: (r.file || "").replace(`qmd://${collection}/`, "").replace(/\.md$/, ""),
-      score: r.score ?? 1 / (i + 1),
-      qmd: r
-    }));
-  }
-  if (fusedResults.length === 0) return [];
-  let scored = fusedResults.map((r) => {
-    const doc = r.doc;
-    const qmd = r.qmd;
-    return {
-      file: doc?.file || qmd?.file || r.id + ".md",
-      title: doc?.title || qmd?.title || r.id,
-      snippet: qmd?.snippet || doc?.content?.slice(0, 300) || "",
-      score: r.score,
-      fusedScore: r.score,
-      scope: doc?.scope || "global"
-    };
-  });
-  if (config.rerankProvider && config.rerankApiKey) {
-    const texts = scored.map((r) => `${r.title || ""} ${r.snippet || ""}`.trim());
-    const rerankScores = await crossEncoderRerank(query, texts, config);
-    if (rerankScores) {
-      scored = scored.map((r, i) => ({
-        ...r,
-        rerankScore: rerankScores[i],
-        fusedScore: config.rerankWeight * rerankScores[i] + (1 - config.rerankWeight) * r.fusedScore
-      }));
-      scored.sort((a, b) => b.fusedScore - a.fusedScore);
-    }
-  }
-  scored = scored.map((r) => {
-    const doc = fusedResults.find((f) => f.id === r.file?.replace(/\.md$/, ""));
-    const modifiedAt = doc?.doc?.modifiedAt;
-    let recencyBoost = 0;
-    let timeDecay = 1;
-    if (modifiedAt) {
-      recencyBoost = computeRecencyBoost(
-        modifiedAt,
-        now,
-        config.recencyHalfLifeDays,
-        config.recencyWeight
-      );
-      timeDecay = computeTimeDecay(modifiedAt, now, config.decayHalfLifeDays);
-    }
-    return {
-      ...r,
-      recencyBoost,
-      timeDecay,
-      fusedScore: (r.fusedScore + recencyBoost) * timeDecay
-    };
-  });
-  if (config.lengthNormAnchor > 0) {
-    scored = scored.map((r) => {
-      const charLen = (r.snippet?.length || 0) + (r.title?.length || 0);
-      const lengthNorm = computeLengthNorm(charLen, config.lengthNormAnchor);
-      return {
-        ...r,
-        lengthNorm,
-        fusedScore: r.fusedScore * lengthNorm
-      };
-    });
-  }
-  scored.sort((a, b) => b.fusedScore - a.fusedScore);
-  if (config.mmrLambda < 1) {
-    const embeddingCache = loadEmbeddingCache(vaultPath);
-    scored = mmrRerank(scored, embeddingCache, config.mmrLambda, config.topK);
-  }
-  return scored.filter((r) => r.fusedScore >= config.minScore).slice(0, config.topK);
-}
-function qmdHybridSearch(query, collection, limit = 10) {
-  const sanitized = query.replace(/['']/g, " ").replace(/[^\w\s\-.,?!]/g, " ").trim();
-  if (!sanitized) return [];
-  const bm25Results = qmdSearch(sanitized, collection, limit);
-  try {
-    const vaultPath = process.env.CLAWVAULT_PATH || join4(
-      process.env.HOME || ".",
-      "clawvault"
-    );
-    const cachePath = join4(vaultPath, ".clawvault", "embeddings.bin.json");
-    if (bm25Results.length > 0 && existsSync4(cachePath)) {
-      const rerankerPath = join4(__dirname, "semantic-rerank.mjs");
-      if (existsSync4(rerankerPath)) {
-        const reranked = execFileSync("node", [
-          rerankerPath,
-          sanitized,
-          cachePath,
-          JSON.stringify(bm25Results)
-        ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], timeout: 1e4 });
-        const parsed = JSON.parse(reranked);
-        if (Array.isArray(parsed) && parsed.length > 0) {
-          return parsed.slice(0, limit);
-        }
-      }
-    }
-  } catch {
-  }
-  return bm25Results.slice(0, limit);
-}
-
-// src/plugin/adaptive-retrieval.ts
-var DEFAULT_ADAPTIVE_CONFIG = {
-  enabled: true,
-  skipPatterns: []
-};
-var GREETING_RE = /^(?:hi|hello|hey|howdy|greetings|good (?:morning|afternoon|evening)|what'?s up|sup|yo)\b/i;
-var FAREWELL_RE = /^(?:bye|goodbye|see you|later|gn|good night|cya|take care)\s*[!.?]*$/i;
-var SLASH_COMMAND_RE = /^\/\w+/;
-var CONFIRMATION_RE = /^(?:ok(?:ay)?|sure|yes|no|yep|nope|y|n|got it|understood|perfect|great|cool|nice|awesome|k|kk|ack|confirmed|roger)\s*[!.?]*$/i;
-var EMOJI_ONLY_RE = /^[\p{Emoji}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Emoji_Component}\s]+$/u;
-var SYSTEM_RE = /^(?:\[System|\[HEARTBEAT|NO_REPLY|<relevant-memories|<session-recap)/;
-var MIN_MEANINGFUL_LENGTH = 8;
-function shouldRetrieve(input, config = DEFAULT_ADAPTIVE_CONFIG) {
-  if (!config.enabled) return { shouldRetrieve: true };
-  if (!input) return { shouldRetrieve: false, skipReason: "too_short" };
-  const trimmed = input.trim();
-  if (SYSTEM_RE.test(trimmed)) {
-    return { shouldRetrieve: false, skipReason: "system_message" };
-  }
-  if (SLASH_COMMAND_RE.test(trimmed)) {
-    return { shouldRetrieve: false, skipReason: "slash_command" };
-  }
-  if (EMOJI_ONLY_RE.test(trimmed)) {
-    return { shouldRetrieve: false, skipReason: "emoji_only" };
-  }
-  if (trimmed.length < MIN_MEANINGFUL_LENGTH) {
-    return { shouldRetrieve: false, skipReason: "too_short" };
-  }
-  if (GREETING_RE.test(trimmed) && trimmed.length < 30) {
-    return { shouldRetrieve: false, skipReason: "greeting" };
-  }
-  if (FAREWELL_RE.test(trimmed)) {
-    return { shouldRetrieve: false, skipReason: "farewell" };
-  }
-  if (CONFIRMATION_RE.test(trimmed)) {
-    return { shouldRetrieve: false, skipReason: "confirmation" };
-  }
-  for (const pattern of config.skipPatterns) {
-    try {
-      const re = new RegExp(pattern, "i");
-      if (re.test(trimmed)) {
-        return { shouldRetrieve: false, skipReason: "user_pattern" };
-      }
-    } catch {
-    }
-  }
-  return { shouldRetrieve: true };
-}
-
-// src/plugin/index.ts
-var PLUGIN_VERSION = "4.0.0";
-function resolveVaultPath(cfg) {
-  if (cfg?.vaultPath) return cfg.vaultPath;
-  if (process.env.CLAWVAULT_PATH) return process.env.CLAWVAULT_PATH;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
-  for (const candidate of [`${home}/clawvault`, `${home}/.clawvault`]) {
-    if (existsSync5(join5(candidate, ".clawvault.json"))) return candidate;
-  }
-  return `${home}/.clawvault`;
-}
-async function autoEmbedViaOllama(filePath, content) {
-  try {
-    const { dirname, join: pathJoin, relative: pathRelative } = await import("path");
-    const { existsSync: fsExists, readFileSync: fsRead, writeFileSync: fsWrite, mkdirSync: fsMkdir } = await import("fs");
-    let vaultPath = dirname(filePath);
-    for (let i = 0; i < 10; i++) {
-      if (fsExists(pathJoin(vaultPath, ".clawvault.json"))) break;
-      const parent = dirname(vaultPath);
-      if (parent === vaultPath) return;
-      vaultPath = parent;
-    }
-    const cachePath = pathJoin(vaultPath, ".clawvault", "embeddings.bin.json");
-    const docId = pathRelative(vaultPath, filePath).replace(/\.md$/, "");
-    const resp = await fetch("http://localhost:11434/api/embeddings", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ model: "nomic-embed-text", prompt: content.slice(0, 2e3) }),
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (!resp.ok) return;
-    const data = await resp.json();
-    let cache = {};
-    try {
-      cache = JSON.parse(fsRead(cachePath, "utf-8"));
-    } catch {
-    }
-    cache[docId] = data.embedding;
-    const dir = dirname(cachePath);
-    if (!fsExists(dir)) fsMkdir(dir, { recursive: true });
-    fsWrite(cachePath, JSON.stringify(cache));
-  } catch {
-  }
-}
-function qmdUpdateAsync(collection) {
-  try {
-    execFile("qmd", ["update", "-c", collection], { timeout: 3e4 }, () => {
-    });
-    execFile("qmd", ["embed", "-c", collection], { timeout: 6e4 }, () => {
-    });
-  } catch {
-  }
-}
-function observeViaCli(vaultPath, content, meta = {}) {
-  try {
-    const args = ["observe", "--content", content];
-    if (meta.tags?.length) args.push("--tags", meta.tags.join(","));
-    execFile("clawvault", args, { cwd: vaultPath, timeout: 15e3 }, () => {
-    });
-  } catch {
-  }
-}
-function computeMemoryStats(vaultPath, collection) {
-  const stats = {
-    vault: vaultPath,
-    version: PLUGIN_VERSION,
-    documents: 0,
-    vectors: 0,
-    categories: {},
-    oldestDoc: null,
-    newestDoc: null,
-    totalSizeKb: 0
-  };
-  const files = scanVaultFiles(vaultPath, { maxAge: Infinity, limit: 1e4 });
-  stats.documents = files.length;
-  for (const file of files) {
-    const cat = file.primitiveType;
-    stats.categories[cat] = (stats.categories[cat] || 0) + 1;
-  }
-  if (files.length > 0) {
-    const sorted = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
-    stats.oldestDoc = sorted[0].modifiedAt.toISOString();
-    stats.newestDoc = sorted[sorted.length - 1].modifiedAt.toISOString();
-  }
-  const cachePath = join5(vaultPath, ".clawvault", "embeddings.bin.json");
-  if (existsSync5(cachePath)) {
-    try {
-      const cacheData = JSON.parse(readFileSync5(cachePath, "utf-8"));
-      stats.vectors = Object.keys(cacheData).length;
-      const cacheStats = statSync3(cachePath);
-      stats.totalSizeKb = Math.round(cacheStats.size / 1024);
-    } catch {
-    }
-  }
-  try {
-    const qmdStats = execFileSync2("qmd", ["status", "--json", "-c", collection], {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const parsed = JSON.parse(qmdStats);
-    if (typeof parsed.documents === "number") stats.documents = Math.max(stats.documents, parsed.documents);
-    if (typeof parsed.vectors === "number") stats.vectors = Math.max(stats.vectors, parsed.vectors);
-  } catch {
-  }
-  return stats;
-}
-function exportMemories(vaultPath, outputPath) {
-  const files = scanVaultFiles(vaultPath, { maxAge: Infinity, limit: 1e5 });
-  const memories = files.map((f) => ({
-    path: f.relativePath,
-    primitiveType: f.primitiveType,
-    frontmatter: f.frontmatter,
-    content: f.content,
-    modifiedAt: f.modifiedAt.toISOString(),
-    createdAt: f.createdAt.toISOString()
-  }));
-  writeFileSync2(outputPath, JSON.stringify(memories, null, 2), "utf-8");
-  return { count: memories.length, path: outputPath };
-}
-function importMemories(vaultPath, inputPath) {
-  const errors = [];
-  let imported = 0;
-  let skipped = 0;
-  try {
-    const data = JSON.parse(readFileSync5(inputPath, "utf-8"));
-    for (const entry of data) {
-      const title = String(entry.frontmatter?.title || entry.frontmatter?.summary || "");
-      const result = writeVaultFile(vaultPath, {
-        primitiveType: entry.primitiveType || "memory_event",
-        title: title.slice(0, 80) || void 0,
-        content: entry.content,
-        extraFields: entry.frontmatter
-      });
-      if (result.success) imported++;
-      else {
-        skipped++;
-        if (result.errors.length > 0) errors.push(...result.errors);
-      }
-    }
-  } catch (err) {
-    errors.push(`Import failed: ${String(err)}`);
-  }
-  return { imported, skipped, errors };
-}
-var templateRegistry = null;
-var clawvaultPlugin = {
-  id: "clawvault",
-  name: "ClawVault Memory",
-  description: "Template-driven observational memory with hybrid search, cross-encoder reranking, and adaptive retrieval. Memories are captured automatically from conversations and classified against template schemas.",
-  version: PLUGIN_VERSION,
-  kind: "memory",
-  register(api) {
-    const cfg = api.pluginConfig || {};
-    const vaultPath = resolveVaultPath(cfg);
-    const collection = cfg.collection || "clawvault";
-    const autoRecall = cfg.autoRecall !== false;
-    const autoCapture = cfg.autoCapture !== false;
-    const recallLimit = cfg.recallLimit || 5;
-    const templatesDir = cfg.templatesDir ?? join5(vaultPath, "..", "..", "templates");
-    const defaultScope = parseScope(cfg.defaultScope || "global");
-    const retrievalConfig = {
-      ...DEFAULT_RETRIEVAL_CONFIG,
-      ...cfg.retrieval
-    };
-    const noiseConfig = {
-      ...DEFAULT_NOISE_CONFIG,
-      ...cfg.noise
-    };
-    const adaptiveConfig = {
-      ...DEFAULT_ADAPTIVE_CONFIG,
-      ...cfg.adaptive
-    };
-    templateRegistry = initializeTemplateRegistry(templatesDir);
-    api.logger.info(`[clawvault] Template registry initialized with ${templateRegistry.schemas.size} schemas`);
-    setAutoEmbedFn(autoEmbedViaOllama);
-    if (!existsSync5(join5(vaultPath, ".clawvault.json"))) {
-      api.logger.warn(`[clawvault] Vault not found at ${vaultPath}`);
-      return;
-    }
-    ensureVaultStructure(vaultPath);
-    api.logger.info(
-      `[clawvault] v${PLUGIN_VERSION} vault=${vaultPath} collection=${collection} recall=${autoRecall} capture=${autoCapture} scope=${defaultScope}`
-    );
-    api.registerTool({
-      name: "memory_search",
-      label: "Memory Search",
-      description: "Search through long-term memories using ClawVault. Uses in-process hybrid retrieval with BM25 + semantic search, RRF fusion, optional reranking, and MMR diversity.",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query \u2014 natural language question or keyword search" }),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ description: "Max results (default: 10)" })),
-        queryType: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("temporal"),
-          import_typebox.Type.Literal("knowledge"),
-          import_typebox.Type.Literal("general")
-        ], { description: "Force query type (auto-detected if omitted)" })),
-        scope: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Memory scope filter (global, agent:<id>, project:<name>, user:<id>)" }))
-      }),
-      async execute(_id, params) {
-        try {
-          let searchQuery = params.query;
-          if (params.queryType === "preference") searchQuery = `preference: ${searchQuery}`;
-          else if (params.queryType === "temporal") searchQuery = `when: ${searchQuery}`;
-          const limit = params.limit || 10;
-          const scope = parseScope(params.scope || defaultScope);
-          const results = await retrieve(searchQuery, {
-            vaultPath,
-            collection,
-            config: { ...retrievalConfig, topK: limit },
-            scope
-          });
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: "No relevant memories found." }],
-              details: { count: 0, provider: "clawvault" }
-            };
-          }
-          const formatted = results.map((r, i) => {
-            const file = (r.file || "").replace(`qmd://${collection}/`, "");
-            const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
-            const score = (r.fusedScore * 100).toFixed(0);
-            return `${i + 1}. [${file}] ${snippet} (${score}%)`;
-          }).join("\n");
-          return {
-            content: [{ type: "text", text: formatted }],
-            details: { count: results.length, provider: "clawvault", pipeline: "hybrid-v2" }
-          };
-        } catch (err) {
-          try {
-            const results = qmdHybridSearch(params.query, collection, params.limit || 10);
-            return {
-              content: [{ type: "text", text: formatSearchResults(results, collection) }],
-              details: { count: results.length, provider: "clawvault", pipeline: "qmd-fallback" }
-            };
-          } catch {
-            return {
-              content: [{ type: "text", text: `Memory search error: ${String(err)}` }],
-              isError: true
-            };
-          }
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_get",
-      label: "Memory Get",
-      description: "Get vault status, stored preferences, or memory stats.",
-      parameters: import_typebox.Type.Object({
-        action: import_typebox.Type.Union([
-          import_typebox.Type.Literal("status"),
-          import_typebox.Type.Literal("preferences"),
-          import_typebox.Type.Literal("stats")
-        ], { description: "What to retrieve" })
-      }),
-      async execute(_id, params) {
-        try {
-          if (params.action === "status" || params.action === "stats") {
-            const stats = computeMemoryStats(vaultPath, collection);
-            return {
-              content: [{ type: "text", text: JSON.stringify({
-                ...stats,
-                autoRecall,
-                autoCapture,
-                templateSchemas: templateRegistry?.schemas.size ?? 0,
-                scope: defaultScope,
-                retrieval: {
-                  rerankProvider: retrievalConfig.rerankProvider || "none",
-                  mmrLambda: retrievalConfig.mmrLambda,
-                  recencyHalfLife: retrievalConfig.recencyHalfLifeDays,
-                  decayHalfLife: retrievalConfig.decayHalfLifeDays
-                }
-              }, null, 2) }]
-            };
-          }
-          const prefContext = buildPreferenceContext(vaultPath, { limit: 20 });
-          if (prefContext.preferenceCount === 0) {
-            const results = qmdHybridSearch("user preference likes dislikes prefers wants", collection, 20);
-            const prefResults = results.filter(
-              (r) => r.file?.includes("preference") || r.snippet?.toLowerCase().match(/prefer|like|want|hate|love|always|never/)
-            );
-            if (prefResults.length === 0) {
-              return { content: [{ type: "text", text: "No preferences found in vault." }] };
-            }
-            const text = prefResults.map((r, i) => {
-              const file = (r.file || "").replace(`qmd://${collection}/`, "");
-              const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title;
-              return `${i + 1}. [${file}] ${snippet}`;
-            }).join("\n");
-            return { content: [{ type: "text", text }] };
-          }
-          return { content: [{ type: "text", text: prefContext.xml }] };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory get error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_store",
-      label: "Memory Store",
-      description: "Save important information in long-term memory. Use for preferences, facts, decisions, or anything worth remembering.",
-      parameters: import_typebox.Type.Object({
-        text: import_typebox.Type.String({ description: "Information to remember" }),
-        category: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("fact"),
-          import_typebox.Type.Literal("decision"),
-          import_typebox.Type.Literal("entity"),
-          import_typebox.Type.Literal("event"),
-          import_typebox.Type.Literal("other")
-        ], { description: "Memory category (auto-detected if omitted)" })),
-        tags: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Tags for organization" })),
-        scope: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Memory scope (global, agent:<id>, project:<name>, user:<id>)" }))
-      }),
-      async execute(_id, params) {
-        try {
-          const text = params.text;
-          if (noiseConfig.enabled) {
-            const check = isNoise(text, noiseConfig);
-            if (check.isNoise) {
-              return {
-                content: [{ type: "text", text: `Skipped: content filtered (${check.reason})` }],
-                details: { action: "filtered", reason: check.reason }
-              };
-            }
-          }
-          const classification = classifyText(text);
-          const category = params.category || detectCategory(text);
-          const tags = params.tags || [category, ...classification.matchedKeywords.slice(0, 3)];
-          const scope = parseScope(params.scope || defaultScope);
-          const CATEGORY_TO_PRIMITIVE = {
-            preference: "memory_event",
-            fact: "memory_event",
-            decision: "decision",
-            entity: "person",
-            event: "memory_event",
-            other: "memory_event"
-          };
-          const effectivePrimitive = params.category ? CATEGORY_TO_PRIMITIVE[params.category] ?? "memory_event" : classification.primitiveType;
-          const extraFields = {
-            type: category,
-            confidence: classification.confidence,
-            tags
-          };
-          if (scope !== "global") extraFields.scope = scope;
-          const result = writeVaultFile(vaultPath, {
-            primitiveType: effectivePrimitive,
-            title: text.slice(0, 80),
-            content: text,
-            extraFields,
-            source: "openclaw"
-          });
-          appendToLedger(vaultPath, {
-            timestamp: /* @__PURE__ */ new Date(),
-            category,
-            content: text,
-            primitiveType: classification.primitiveType,
-            tags
-          });
-          qmdUpdateAsync(collection);
-          return {
-            content: [{ type: "text", text: `Stored: "${text.slice(0, 100)}${text.length > 100 ? "..." : ""}" [${classification.primitiveType}/${category}]${scope !== "global" ? ` scope=${scope}` : ""}` }],
-            details: {
-              action: result.created ? "created" : "updated",
-              category,
-              primitiveType: classification.primitiveType,
-              path: result.path,
-              scope
-            }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory store error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_forget",
-      label: "Memory Forget",
-      description: "Delete specific memories from the vault.",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query to find the memory to delete" }),
-        confirm: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Set true to confirm deletion of first match" }))
-      }),
-      async execute(_id, params) {
-        try {
-          const results = qmdHybridSearch(params.query, collection, 5);
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: "No matching memories found." }],
-              details: { found: 0 }
-            };
-          }
-          if (!params.confirm) {
-            const list = results.map((r, i) => {
-              const file2 = (r.file || "").replace(`qmd://${collection}/`, "");
-              const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim().slice(0, 80);
-              return `${i + 1}. [${file2}] ${snippet}`;
-            }).join("\n");
-            return {
-              content: [{ type: "text", text: `Found ${results.length} candidates:
-${list}
-
-Call again with confirm=true to delete the top match.` }],
-              details: { action: "candidates", count: results.length }
-            };
-          }
-          const target = results[0];
-          const file = (target.file || "").replace(`qmd://${collection}/`, "");
-          const fullPath = join5(vaultPath, file);
-          if (existsSync5(fullPath)) {
-            const trashDir = join5(vaultPath, ".trash");
-            if (!existsSync5(trashDir)) mkdirSync2(trashDir, { recursive: true });
-            const trashPath = join5(trashDir, `${Date.now()}-${basename(file)}`);
-            renameSync(fullPath, trashPath);
-            qmdUpdateAsync(collection);
-            return {
-              content: [{ type: "text", text: `Forgotten: [${file}] (moved to .trash)` }],
-              details: { action: "deleted", file, trashPath }
-            };
-          }
-          return {
-            content: [{ type: "text", text: `File not found on disk: ${file}` }],
-            details: { action: "not_found", file }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory forget error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    if (autoRecall) {
-      api.on("before_agent_start", async (event) => {
-        const prompt = event.prompt;
-        if (!prompt || prompt.length < 10) return;
-        if (prompt.includes("HEARTBEAT") || prompt.startsWith("[System")) return;
-        if (prompt.includes("#clawvault:no-recall") || prompt.includes("#clawvault:no-memory")) return;
-        if (adaptiveConfig.enabled) {
-          const check = shouldRetrieve(prompt, adaptiveConfig);
-          if (!check.shouldRetrieve) {
-            api.logger.debug(`[clawvault] adaptive skip: ${check.skipReason}`);
-            return;
-          }
-        }
-        try {
-          const contextParts = [];
-          const recap = buildSessionRecap(vaultPath, {
-            maxAge: 24 * 60 * 60 * 1e3,
-            limit: 10,
-            includeContent: true
-          });
-          if (recap.xml) contextParts.push(recap.xml);
-          const searchTerms = extractSearchTerms(prompt);
-          try {
-            const results = await retrieve(searchTerms, {
-              vaultPath,
-              collection,
-              config: { ...retrievalConfig, topK: recallLimit },
-              scope: defaultScope
-            });
-            if (results.length > 0 && results[0].fusedScore >= 0.01) {
-              const formatted = results.map((r, i) => {
-                const file = r.file || "";
-                const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "";
-                return `${i + 1}. [${file}] ${snippet}`;
-              });
-              contextParts.push(`<relevant-memories>
-These are recalled from long-term vault memory. Treat as historical context.
-${formatted.join("\n")}
-</relevant-memories>`);
-              api.logger.info(
-                `[clawvault] auto-recall: ${results.length} memories (top: ${(results[0].fusedScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}", pipeline: hybrid-v2)`
-              );
-            }
-          } catch {
-            const results = qmdHybridSearch(searchTerms, collection, recallLimit);
-            if (results.length > 0) {
-              const topScore = results[0]?.score ?? 0;
-              if (topScore >= 0.25) {
-                contextParts.push(formatMemoriesForContext(results, collection));
-                api.logger.info(
-                  `[clawvault] auto-recall: ${results.length} memories (top: ${(topScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}", pipeline: qmd-fallback)`
-                );
-              }
-            }
-          }
-          if (contextParts.length === 0) return;
-          return { prependContext: contextParts.join("\n\n") };
-        } catch (err) {
-          api.logger.warn(`[clawvault] auto-recall failed: ${String(err)}`);
-        }
-      }, { priority: 10 });
-    }
-    if (autoCapture) {
-      api.on("message_received", async (event) => {
-        const content = event.content;
-        if (!content || !isObservable(content, noiseConfig)) return;
-        if (content.includes("#clawvault:no-capture") || content.includes("#clawvault:no-memory")) return;
-        if (noiseConfig.enabled && isNoise(content, noiseConfig).isNoise) return;
-        try {
-          const result = processMessageForObservations(content, {
-            from: event.from,
-            sessionId: event.sessionId
-          });
-          if (result.observations.length === 0) return;
-          const writeResult = batchWriteObservations(vaultPath, result.observations, {
-            source: "openclaw",
-            sessionId: event.sessionId,
-            actor: event.from || "user",
-            writeLedger: true,
-            writeFiles: false
-          });
-          api.logger.info(`[clawvault] auto-captured ${writeResult.successful} observations from incoming message`);
-        } catch (err) {
-          api.logger.warn(`[clawvault] message capture failed: ${String(err)}`);
-        }
-      });
-      api.on("agent_end", async (event) => {
-        if (!event.success || !event.messages) return;
-        const messages = event.messages;
-        try {
-          let captured = 0;
-          for (const msg of messages) {
-            if (!msg || typeof msg !== "object") continue;
-            if (msg.role === "user") {
-              const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((b) => b?.type === "text").map((b) => b.text || "").join(" ") : "";
-              if (isObservable(content, noiseConfig) && !isNoise(content, noiseConfig).isNoise) {
-                const result = processMessageForObservations(content);
-                for (const obs of result.observations) {
-                  observeViaCli(vaultPath, obs.text, { tags: obs.tags });
-                  captured++;
-                }
-              }
-            }
-          }
-          if (captured > 0) {
-            api.logger.info(`[clawvault] agent_end: captured ${captured} observations`);
-            qmdUpdateAsync(collection);
-          }
-        } catch (err) {
-          api.logger.warn(`[clawvault] agent_end capture failed: ${String(err)}`);
-        }
-      });
-    }
-    api.on("before_compaction", async () => {
-      try {
-        execFileSync2("qmd", ["update", "-c", collection], {
-          timeout: 15e3,
-          encoding: "utf-8",
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        api.logger.info("[clawvault] pre-compaction index update complete");
-      } catch (err) {
-        api.logger.warn(`[clawvault] pre-compaction update failed: ${String(err)}`);
-      }
-    });
-    api.registerService({
-      id: "clawvault",
-      start: () => {
-        api.logger.info(`[clawvault] service started \u2014 vault=${vaultPath}`);
-        qmdUpdateAsync(collection);
-      },
-      stop: () => {
-        api.logger.info("[clawvault] service stopped");
-      }
-    });
-    api.registerCli(
-      (ctx) => {
-        const cmd = ctx.program.command("vault").description("ClawVault memory commands");
-        cmd.command("status").action(() => {
-          const stats = computeMemoryStats(vaultPath, collection);
-          console.log(JSON.stringify(stats, null, 2));
-        });
-        cmd.command("search <query>").option("-n, --limit <n>", "Max results", "10").action((query, opts) => {
-          const results = qmdHybridSearch(query, collection, parseInt(opts.limit || "10"));
-          console.log(formatSearchResults(results, collection));
-        });
-        cmd.command("templates").action(() => {
-          const schemas = getAllSchemas();
-          console.log("Registered template schemas:");
-          for (const schema of schemas) {
-            console.log(`  - ${schema.primitive}: ${schema.description || "(no description)"}`);
-            console.log(`    Fields: ${Object.keys(schema.fields).join(", ")}`);
-          }
-        });
-        cmd.command("classify <text>").action((text) => {
-          const result = classifyText(text);
-          console.log(JSON.stringify(result, null, 2));
-        });
-        cmd.command("stats").action(() => {
-          const stats = computeMemoryStats(vaultPath, collection);
-          console.log(JSON.stringify(stats, null, 2));
-        });
-        cmd.command("export <outputPath>").action((outputPath) => {
-          const result = exportMemories(vaultPath, outputPath);
-          console.log(`Exported ${result.count} memories to ${result.path}`);
-        });
-        cmd.command("import <inputPath>").action((inputPath) => {
-          const result = importMemories(vaultPath, inputPath);
-          console.log(`Imported: ${result.imported}, Skipped: ${result.skipped}`);
-          if (result.errors.length > 0) {
-            console.log(`Errors: ${result.errors.join(", ")}`);
-          }
-        });
-        cmd.command("reembed").action(() => {
-          console.log("Re-embedding all vault documents...");
-          const files = scanVaultFiles(vaultPath, { maxAge: Infinity, limit: 1e5 });
-          let count = 0;
-          for (const file of files) {
-            const content = `${file.frontmatter.title || ""} ${file.content}`.trim();
-            autoEmbedViaOllama(file.path, content).then(() => {
-              count++;
-              if (count % 100 === 0) console.log(`  Embedded ${count}/${files.length}...`);
-            }).catch(() => {
-            });
-          }
-          console.log(`Queued ${files.length} documents for re-embedding.`);
-        });
-      },
-      { commands: ["vault"] }
-    );
-    api.registerCommand({
-      name: "vault",
-      description: "ClawVault status and quick search",
-      acceptsArgs: true,
-      requireAuth: true,
-      handler: (ctx) => {
-        const args = (ctx.args || "").trim();
-        if (!args || args === "status") {
-          const stats = computeMemoryStats(vaultPath, collection);
-          return {
-            text: `\u{1F9E0} ClawVault v${PLUGIN_VERSION}
-Vault: ${vaultPath}
-Docs: ${stats.documents} | Vectors: ${stats.vectors}
-Recall: ${autoRecall ? "\u2705" : "\u274C"} | Capture: ${autoCapture ? "\u2705" : "\u274C"}
-Templates: ${templateRegistry?.schemas.size ?? 0} schemas
-Scope: ${defaultScope}
-Pipeline: hybrid-v2 (BM25+Semantic+RRF${retrievalConfig.rerankProvider ? `+${retrievalConfig.rerankProvider}` : ""})`
-          };
-        }
-        if (args.startsWith("search ")) {
-          const query = args.slice(7).trim();
-          const results = qmdHybridSearch(query, collection, 5);
-          return { text: formatSearchResults(results, collection) };
-        }
-        if (args === "templates") {
-          const names = getSchemaNames();
-          return { text: `Template schemas: ${names.join(", ")}` };
-        }
-        if (args === "recap") {
-          const recap = buildSessionRecap(vaultPath, { limit: 10, includeContent: true });
-          return { text: recap.xml || "No recent activity found." };
-        }
-        if (args === "stats") {
-          const stats = computeMemoryStats(vaultPath, collection);
-          return { text: JSON.stringify(stats, null, 2) };
-        }
-        return { text: "Usage: /vault [status|search <query>|templates|recap|stats]" };
-      }
-    });
-    console.log(
-      `[clawvault] v${PLUGIN_VERSION} registered \u2014 vault=${vaultPath} templates=${templateRegistry?.schemas.size ?? 0} pipeline=hybrid-v2 scope=${defaultScope}`
-    );
-  }
-};
-var plugin_default = clawvaultPlugin;
-export {
-  appendToLedger,
-  batchWriteObservations,
-  buildFullContext,
-  buildPreferenceContext,
-  buildSessionRecap,
-  classifyText,
-  plugin_default as default,
-  detectCategory,
-  ensureVaultStructure,
-  extractObservations,
-  extractSearchTerms,
-  formatMemoriesForContext,
-  formatSearchResults,
-  getAllSchemas,
-  getSchema,
-  getSchemaNames,
-  getTemplateRegistry,
-  initializeTemplateRegistry,
-  isObservable,
-  processMessageForObservations,
-  scanVaultFiles,
-  writeObservation,
-  writeVaultFile
-};