@openclaw/lobster 2026.9.5 → 2026.9.7

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/mailto-authority-security.test.js

@@ -0,0 +1,125 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+// GHSA-88VG-QFHM-JX5Q: `mailto://h/a` carries an authority (which RFC 6068 does
+// not define for `mailto`) and a path. `mailtoParse` used to retain that
+// authority and fold the path's leading "/" into the recipient local part; the
+// generic serializer then reinserted a "/" separator on every pass, so
+// serialize(parse(x)) was not a fixpoint and normalize() accreted one "%2F" per
+// pass (unbounded growth for a renormalize-to-fixpoint consumer).
+
+const authorityForms = [
+  ['mailto://h/a', 'mailto:%2Fa@'],
+  ['mailto://h/a@b', 'mailto:%2Fa@b'],
+  ['mailto://h/', 'mailto:%2F@'],
+  ['mailto://h/a,b', 'mailto:%2Fa@,b@'],
+  ['mailto://user@h/a', 'mailto:%2Fa@'],
+  ['mailto://h:8080/a', 'mailto:%2Fa@'],
+  ['mailto://', 'mailto://'],
+  // recipients can come from a `to=` hfield even when the path is empty
+  ['mailto://h?to=x@y', 'mailto:x@y'],
+  ['mailto://h?to=x@y&to=a@b', 'mailto:x@y,a@b']
+]
+
+test('mailto with a retained authority and a path normalizes to a fixpoint', (t) => {
+  t.plan(authorityForms.length * 2)
+
+  for (const [input] of authorityForms) {
+    const once = fastURI.normalize(input)
+    const twice = fastURI.normalize(once)
+
+    t.equal(twice, once, input + ' normalize is idempotent')
+    t.equal(fastURI.equal(input, once), true, input + ' equals its normalized form')
+  }
+})
+
+test('mailto serialize(parse()) is a stable round trip for the authority form', (t) => {
+  t.plan(authorityForms.length)
+
+  for (const [input, expected] of authorityForms) {
+    t.equal(fastURI.serialize(fastURI.parse(input)), expected, input + ' round trips to a stable value')
+  }
+})
+
+test('mailto authority form does not grow without bound under renormalization', (t) => {
+  // A renormalize-to-fixpoint loop must terminate instead of growing forever.
+  // A single normalize call already terminates, so this guards the fixpoint.
+  const inputs = ['mailto://h/a', 'mailto://h/a@b', 'mailto://h/a,b']
+
+  t.plan(inputs.length * 2)
+
+  for (const input of inputs) {
+    const first = fastURI.normalize(input)
+    let s = input
+    let iters = 0
+    let stable = false
+    while (iters < 1000) {
+      const next = fastURI.normalize(s)
+      if (next === s) {
+        stable = true
+        break
+      }
+      s = next
+      iters++
+    }
+
+    t.equal(stable, true, input + ' reaches a fixpoint')
+    t.equal(s.length, first.length, input + ' does not grow')
+  }
+})
+
+test('mailto authority handling preserves host normalization for skip-normalize schemes', (t) => {
+  // Regression: a bare `mailto://host` with no path must keep its host and stay
+  // idempotent, so the generic host normalization path is unaffected.
+  const encodedHost = 'mailto://%41.com'
+  const literalHost = 'mailto://a.com'
+
+  t.equal(fastURI.parse(encodedHost).host, fastURI.parse(literalHost).host, 'parse results have consistent hosts')
+  t.equal(fastURI.normalize(encodedHost), fastURI.normalize(literalHost), 'normalize results are consistent')
+  t.equal(fastURI.equal(encodedHost, literalHost), true, 'encoded and literal hosts compare equal')
+  t.equal(fastURI.normalize(literalHost), literalHost, 'bare authority mailto is idempotent')
+  t.end()
+})
+
+test('mailto authority form is reported as malformed on the parsed component', (t) => {
+  t.equal(
+    fastURI.parse('mailto://h/a').error,
+    'URI mailto must not have an authority component.',
+    'the retained authority is surfaced as an error'
+  )
+
+  // A valid, authority-free mailto must not be flagged.
+  t.equal(fastURI.parse('mailto:user@host.com').error, undefined, 'well-formed mailto has no error')
+  t.end()
+})
+
+test('mailto serializer drops caller-supplied authority when recipients are present', (t) => {
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h', to: ['a@b'] }),
+    'mailto:a@b',
+    'authority is dropped for direct recipients'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', userinfo: 'u', host: 'h', port: 8080, to: ['a@b'] }),
+    'mailto:a@b',
+    'userinfo, host, and port are dropped for direct recipients'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h', headers: { to: 'a@b' } }),
+    'mailto:a@b',
+    'authority is dropped for recipients supplied through a to hfield'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h', to: ['a@b'], subject: 'hello' }),
+    'mailto:a@b?subject=hello',
+    'dropping authority preserves header fields'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', host: 'h' }),
+    'mailto://h',
+    'bare authority without recipients remains idempotent'
+  )
+  t.end()
+})

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/mailto-field-name-security.test.js

@@ -0,0 +1,151 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+function encodeCharacter (value, index, lowercaseHex) {
+  let hex = value.charCodeAt(index).toString(16)
+  if (!lowercaseHex) hex = hex.toUpperCase()
+  return value.slice(0, index) + '%' + hex + value.slice(index + 1)
+}
+
+function mailtoState (component) {
+  return {
+    to: component.to,
+    subject: component.subject,
+    body: component.body,
+    headers: component.headers && { ...component.headers }
+  }
+}
+
+test('mailto parsing classifies decoded, case-insensitive reserved field names', (t) => {
+  const cases = [
+    { name: 'to', value: 'attacker@evil.test', property: 'to' },
+    { name: 'subject', value: 'injected subject', property: 'subject' },
+    { name: 'body', value: 'injected body', property: 'body' }
+  ]
+
+  for (const entry of cases) {
+    const variants = new Set([entry.name.toUpperCase()])
+    for (let i = 0; i < entry.name.length; i++) {
+      variants.add(encodeCharacter(entry.name, i, false))
+      variants.add(encodeCharacter(entry.name, i, true))
+    }
+
+    for (const name of variants) {
+      const parsed = fastURI.parse(`mailto:alice@example.test?${name}=${entry.value}`)
+      if (entry.property === 'to') {
+        t.deepEqual(parsed.to, ['alice@example.test', entry.value], name + ' is classified as a recipient')
+      } else {
+        t.equal(parsed[entry.property], entry.value, name + ' is classified as ' + entry.property)
+      }
+      t.equal(parsed.headers, undefined, name + ' is not exposed as a generic header')
+
+      const reparsed = fastURI.parse(fastURI.serialize(parsed))
+      t.deepEqual(mailtoState(reparsed), mailtoState(parsed), name + ' keeps its meaning after a roundtrip')
+    }
+  }
+
+  t.end()
+})
+
+test('mailto generic field names are decoded exactly once across roundtrips', (t) => {
+  const cases = [
+    ['%2574o', '%74o'],
+    ['%2573ubject', '%73ubject'],
+    ['%2562ody', '%62ody'],
+    ['x%2520y', 'x%20y'],
+    ['%26to', '&to'],
+    ['%25GGto', '%GGto']
+  ]
+
+  for (const [encodedName, decodedName] of cases) {
+    let serialized = `mailto:alice@example.test?${encodedName}=value`
+    for (let round = 0; round < 3; round++) {
+      const parsed = fastURI.parse(serialized)
+      t.deepEqual({ ...parsed.headers }, { [decodedName]: 'value' }, encodedName + ' stays generic in round ' + round)
+      t.deepEqual(parsed.to, ['alice@example.test'], encodedName + ' does not add a recipient in round ' + round)
+      t.equal(parsed.subject, undefined, encodedName + ' does not set a subject in round ' + round)
+      t.equal(parsed.body, undefined, encodedName + ' does not set a body in round ' + round)
+      serialized = fastURI.serialize(parsed)
+    }
+    t.equal(serialized, `mailto:alice@example.test?${encodedName}=value`, encodedName + ' serializes idempotently')
+  }
+
+  t.equal(
+    fastURI.serialize({ scheme: 'mailto', to: ['alice@example.test'], headers: { '%74o': 'value' } }),
+    'mailto:alice@example.test?%2574o=value',
+    'a percent sequence in a decoded component key is encoded as data'
+  )
+  t.end()
+})
+
+test('mailto serialization canonicalizes reserved generic header names', (t) => {
+  const serialized = fastURI.serialize({
+    scheme: 'mailto',
+    to: ['alice@example.test'],
+    subject: 'safe subject',
+    body: 'safe body',
+    headers: {
+      TO: 'attacker@evil.test',
+      Subject: 'hidden subject',
+      BODY: 'hidden body',
+      cc: 'copy@example.test'
+    }
+  })
+
+  t.equal(
+    serialized,
+    'mailto:alice@example.test,attacker@evil.test?subject=safe%20subject&body=safe%20body&cc=copy@example.test',
+    'dedicated properties override header variants and all recipients are visible in the path'
+  )
+
+  const parsed = fastURI.parse(serialized)
+  t.deepEqual(parsed.to, ['alice@example.test', 'attacker@evil.test'], 'canonical recipients are classified consistently')
+  t.equal(parsed.subject, 'safe subject', 'the dedicated subject wins')
+  t.equal(parsed.body, 'safe body', 'the dedicated body wins')
+  t.deepEqual({ ...parsed.headers }, { cc: 'copy@example.test' }, 'only generic headers remain generic')
+
+  const empty = fastURI.serialize({
+    scheme: 'mailto',
+    to: ['alice@example.test'],
+    subject: '',
+    body: '',
+    headers: { Subject: 'hidden subject', BODY: 'hidden body' }
+  })
+  t.equal(empty, 'mailto:alice@example.test?subject=&body=', 'explicit empty properties override header variants')
+  const emptyParsed = fastURI.parse(empty)
+  t.equal(emptyParsed.subject, '', 'an empty subject round-trips')
+  t.equal(emptyParsed.body, '', 'an empty body round-trips')
+  t.end()
+})
+
+test('mailto duplicate reserved fields have deterministic parsing semantics', (t) => {
+  const parsed = fastURI.parse(
+    'mailto:alice@example.test?subject=first&%53UBJECT=last&body=first&%42ODY=last&to=one@example.test&%54O=two@example.test'
+  )
+
+  t.equal(parsed.subject, 'last', 'the last subject wins')
+  t.equal(parsed.body, 'last', 'the last body wins')
+  t.deepEqual(
+    parsed.to,
+    ['alice@example.test', 'one@example.test', 'two@example.test'],
+    'all recipient fields are accumulated'
+  )
+  t.equal(parsed.headers, undefined, 'no reserved spelling remains generic')
+  t.end()
+})
+
+test('encoded reserved field names expose decoded control characters immediately', (t) => {
+  const input = 'mailto:alice@example.test?%73ubject=hello%0D%0Aworld'
+  const parsed = fastURI.parse(input)
+
+  t.equal(parsed.subject, 'hello\r\nworld', 'the first parse exposes CRLF in the dedicated property')
+  t.equal(parsed.headers, undefined, 'the subject is not hidden as a generic header')
+  t.equal(
+    fastURI.parse(fastURI.serialize(parsed)).subject,
+    parsed.subject,
+    'the decoded subject remains stable after a roundtrip'
+  )
+  t.end()
+})

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/test/security-normalization.test.js

@@ -126,6 +126,44 @@ test('hostname normalization decodes only current unreserved escapes', (t) => {
   t.end()
 })
 
+test('scheme-relative hostname normalization folds decoded ASCII case', (t) => {
+  const encodedHost = '//%41.com'
+  const normalizedHost = fastURI.normalize(encodedHost)
+  const encodedMetadata = '//%4Detadata.internal/private'
+  const literalMetadata = '//metadata.internal/private'
+
+  t.equal(fastURI.parse(encodedHost).host, 'a.com', 'parse folds an encoded uppercase host letter')
+  t.equal(normalizedHost, '//a.com', 'normalize emits a lowercase host')
+  t.equal(fastURI.normalize(normalizedHost), normalizedHost, 'host normalization is idempotent')
+  t.equal(fastURI.equal(encodedHost, '//a.com'), true, 'encoded and literal host spellings compare equal')
+  t.equal(fastURI.equal(encodedMetadata, literalMetadata), true, 'encoded metadata host compares equal')
+  t.equal(
+    fastURI.resolve('x://trusted.example/', encodedMetadata),
+    fastURI.resolve('x://trusted.example/', literalMetadata),
+    'encoded and literal metadata hosts resolve identically'
+  )
+  t.equal(
+    fastURI.normalize('//example.com%2fpath'),
+    '//example.com%2Fpath',
+    'reserved host escapes remain encoded with uppercase hex'
+  )
+  t.equal(fastURI.normalize('//%2541.com'), '//%2541.com', 'nested host escapes are not decoded twice')
+  t.equal(fastURI.equal('//User@%41.com/path', '//user@a.com/path'), false, 'userinfo remains case-sensitive')
+  t.equal(fastURI.equal('//%41.com/Path', '//a.com/path'), false, 'path remains case-sensitive')
+  t.equal(fastURI.equal('//%41.com/?Token=Value', '//a.com/?token=value'), false, 'query remains case-sensitive')
+  t.end()
+})
+
+test('host normalization applies to schemes that skip path normalization', (t) => {
+  const encodedHost = 'mailto://%41.com'
+  const literalHost = 'mailto://a.com'
+
+  t.equal(fastURI.parse(encodedHost).host, fastURI.parse(literalHost).host, 'parse results have consistent hosts')
+  t.equal(fastURI.normalize(encodedHost), fastURI.normalize(literalHost), 'normalize results are consistent')
+  t.equal(fastURI.equal(encodedHost, literalHost), true, 'encoded and literal hosts compare equal')
+  t.end()
+})
+
 test('host conversion failures are not treated as comparable URLs', (t) => {
   const malformedHost = 'http://trusted.test%2540evil.test/'
 

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/types/index.d.ts

@@ -5,6 +5,22 @@ declare namespace fastUri {
     scheme?: string;
     userinfo?: string;
     host?: string;
+    /**
+     * Zone identifier of a zoned IPv6 host, e.g. `"eth0"` or `"25eth0"`. Set by
+     * `parse` for a bracketed IPv6 literal so `serialize`/`normalize` can
+     * reproduce the exact zone without re-deriving it from the ambiguous
+     * single-`%` form. It is validated on use, so a value that does not match
+     * `host` (for example after `host` is reassigned) is ignored.
+     *
+     * When building a component object by hand, set `ipv6Zone` to disambiguate
+     * a single-`%` host whose zone is ambiguous (a zone beginning with `25`
+     * is re-read as a `%25` separator). Without it, `serialize` falls back to
+     * a best-effort heuristic and may reinterpret such a zone, e.g. `{ host:
+     * "fe80::1%25eth0" }` serializes to `[fe80::1%25eth0]` (zone `eth0`), while
+     * `{ host: "fe80::1%25eth0", ipv6Zone: "25eth0" }` serializes to
+     * `[fe80::1%2525eth0]` (zone `25eth0`).
+     */
+    ipv6Zone?: string;
     port?: number | string;
     path?: string;
     query?: string;

package/node_modules/@clawdbot/lobster/node_modules/yaml/browser/dist/compose/resolve-flow-scalar.js

@@ -64,46 +64,47 @@ function plainValue(source, onError) {
     }
     if (badChar)
         onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
-    return foldLines(source);
+    return unfoldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
-    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+    return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
-function foldLines(source) {
+function unfoldLines(source) {
+    const line = /(.*?)\r?\n/sy;
+    let match = line.exec(source);
+    if (!match)
+        return source;
     /**
-     * The negative lookbehind here and in the `re` RegExp is to
+     * The negative lookbehinds in these RegExps are to
      * prevent causing a polynomial search time in certain cases.
      *
-     * The try-catch is for Safari, which doesn't support this yet:
+     * The try-catch is for Safari < 16.4 and other old browsers:
      * https://caniuse.com/js-regexp-lookbehind
      */
-    let first, line;
+    let trimEnd, trimBoth;
     try {
-        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
-        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+        trimEnd = new RegExp('(?<![ \t])[ \t]+$');
+        trimBoth = new RegExp('^[ \t]+|(?<![ \t])[ \t]+$', 'g');
     }
     catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
     }
-    let match = first.exec(source);
-    if (!match)
-        return source;
-    let res = match[1];
+    let res = match[1].replace(trimEnd, '');
     let sep = ' ';
-    let pos = first.lastIndex;
-    line.lastIndex = pos;
+    let pos = line.lastIndex;
     while ((match = line.exec(source))) {
-        if (match[1] === '') {
+        const lm = match[1].replace(trimBoth, '');
+        if (lm === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + match[1];
+            res += sep + lm;
             sep = ' ';
         }
         pos = line.lastIndex;

package/node_modules/@clawdbot/lobster/node_modules/yaml/browser/dist/nodes/Alias.js

@@ -43,38 +43,40 @@ class Alias extends NodeBase {
             if (node.anchor === this.source)
                 found = node;
         }
+        if (found && ctx) {
+            const { anchors, doc, maxAliasCount } = ctx;
+            let data = anchors.get(found);
+            if (!data) {
+                // Resolve anchors for Node.prototype.toJS()
+                toJS(found, null, ctx);
+                data = anchors.get(found);
+            }
+            /* istanbul ignore if */
+            if (data?.res === undefined) {
+                const msg = 'This should not happen: Alias anchor was not resolved?';
+                throw new ReferenceError(msg);
+            }
+            if (maxAliasCount >= 0) {
+                data.count += 1;
+                if (data.aliasCount === 0)
+                    data.aliasCount = getAliasCount(doc, found, anchors);
+                if (data.count * data.aliasCount > maxAliasCount) {
+                    const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                    throw new ReferenceError(msg);
+                }
+            }
+        }
         return found;
     }
     toJSON(_arg, ctx) {
         if (!ctx)
             return { source: this.source };
-        const { anchors, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);
         }
-        let data = anchors.get(source);
-        if (!data) {
-            // Resolve anchors for Node.prototype.toJS()
-            toJS(source, null, ctx);
-            data = anchors.get(source);
-        }
-        /* istanbul ignore if */
-        if (data?.res === undefined) {
-            const msg = 'This should not happen: Alias anchor was not resolved?';
-            throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-            data.count += 1;
-            if (data.aliasCount === 0)
-                data.aliasCount = getAliasCount(doc, source, anchors);
-            if (data.count * data.aliasCount > maxAliasCount) {
-                const msg = 'Excessive alias count indicates a resource exhaustion attack';
-                throw new ReferenceError(msg);
-            }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
     }
     toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;

package/node_modules/@clawdbot/lobster/node_modules/yaml/dist/compose/resolve-flow-scalar.js

@@ -66,46 +66,47 @@ function plainValue(source, onError) {
     }
     if (badChar)
         onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
-    return foldLines(source);
+    return unfoldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
-    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+    return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
-function foldLines(source) {
+function unfoldLines(source) {
+    const line = /(.*?)\r?\n/sy;
+    let match = line.exec(source);
+    if (!match)
+        return source;
     /**
-     * The negative lookbehind here and in the `re` RegExp is to
+     * The negative lookbehinds in these RegExps are to
      * prevent causing a polynomial search time in certain cases.
      *
-     * The try-catch is for Safari, which doesn't support this yet:
+     * The try-catch is for Safari < 16.4 and other old browsers:
      * https://caniuse.com/js-regexp-lookbehind
      */
-    let first, line;
+    let trimEnd, trimBoth;
     try {
-        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
-        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+        trimEnd = new RegExp('(?<![ \t])[ \t]+$');
+        trimBoth = new RegExp('^[ \t]+|(?<![ \t])[ \t]+$', 'g');
     }
     catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
     }
-    let match = first.exec(source);
-    if (!match)
-        return source;
-    let res = match[1];
+    let res = match[1].replace(trimEnd, '');
     let sep = ' ';
-    let pos = first.lastIndex;
-    line.lastIndex = pos;
+    let pos = line.lastIndex;
     while ((match = line.exec(source))) {
-        if (match[1] === '') {
+        const lm = match[1].replace(trimBoth, '');
+        if (lm === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + match[1];
+            res += sep + lm;
             sep = ' ';
         }
         pos = line.lastIndex;

package/node_modules/@clawdbot/lobster/node_modules/yaml/dist/nodes/Alias.js

@@ -45,38 +45,40 @@ class Alias extends Node.NodeBase {
             if (node.anchor === this.source)
                 found = node;
         }
+        if (found && ctx) {
+            const { anchors, doc, maxAliasCount } = ctx;
+            let data = anchors.get(found);
+            if (!data) {
+                // Resolve anchors for Node.prototype.toJS()
+                toJS.toJS(found, null, ctx);
+                data = anchors.get(found);
+            }
+            /* istanbul ignore if */
+            if (data?.res === undefined) {
+                const msg = 'This should not happen: Alias anchor was not resolved?';
+                throw new ReferenceError(msg);
+            }
+            if (maxAliasCount >= 0) {
+                data.count += 1;
+                if (data.aliasCount === 0)
+                    data.aliasCount = getAliasCount(doc, found, anchors);
+                if (data.count * data.aliasCount > maxAliasCount) {
+                    const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                    throw new ReferenceError(msg);
+                }
+            }
+        }
         return found;
     }
     toJSON(_arg, ctx) {
         if (!ctx)
             return { source: this.source };
-        const { anchors, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);
         }
-        let data = anchors.get(source);
-        if (!data) {
-            // Resolve anchors for Node.prototype.toJS()
-            toJS.toJS(source, null, ctx);
-            data = anchors.get(source);
-        }
-        /* istanbul ignore if */
-        if (data?.res === undefined) {
-            const msg = 'This should not happen: Alias anchor was not resolved?';
-            throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-            data.count += 1;
-            if (data.aliasCount === 0)
-                data.aliasCount = getAliasCount(doc, source, anchors);
-            if (data.count * data.aliasCount > maxAliasCount) {
-                const msg = 'Excessive alias count indicates a resource exhaustion attack';
-                throw new ReferenceError(msg);
-            }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
     }
     toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;

package/node_modules/@clawdbot/lobster/node_modules/yaml/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "license": "ISC",
   "author": "Eemeli Aro <eemeli@gmail.com>",
   "funding": "https://github.com/sponsors/eemeli",

package/node_modules/@clawdbot/lobster/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@clawdbot/lobster",
-	"version": "2026.9.8",
+	"version": "2026.9.13",
 	"description": "Workflow runtime for AI agents - deterministic pipelines with approval gates",
 	"keywords": [
 		"ai-agent",
@@ -62,15 +62,13 @@
 		"yaml": "^2.9.0"
 	},
 	"devDependencies": {
-		"@types/node": "^26.4.1",
-		"@typescript/native": "npm:typescript@^7.0.2",
-		"oxfmt": "^0.66.0",
-		"oxlint": "^1.81.0",
-		"oxlint-tsgolint": "^7.0.2001",
-		"typescript": "npm:@typescript/typescript6@^6.0.2"
+		"@types/node": "^22.20.2",
+		"oxfmt": "^0.67.0",
+		"oxlint": "^1.82.0",
+		"typescript": "^7.0.2"
 	},
 	"engines": {
 		"node": ">=22"
 	},
-	"packageManager": "pnpm@12.3.4"
+	"packageManager": "pnpm@12.4.1"
 }

package/node_modules/typebox/build/compile/code.mjs

@@ -16,9 +16,8 @@ function Separator() {
 function ImportSection(build) {
     const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
     const hashing = `import { Hashing } from "typebox/system"`;
-    const format = `import { Format } from "typebox/format"`;
     const guard = `import { Guard } from "typebox/guard"`;
-    return [...context, hashing, format, guard];
+    return [...context, hashing, guard];
 }
 // ------------------------------------------------------------------
 // ExternalSection