@sanity/runtime-cli 17.0.0 → 17.1.0-next.gcfbd613

package/dist/server/static/vendor/vendor.bundle.js

@@ -4515,7 +4515,7 @@ function nextClusterBreak(str, pos, includeExtending) {
 }
 
 function prevClusterBreak(str, pos, includeExtending) {
-  while (pos > 0) {
+  while (pos > 1) {
     let found = nextClusterBreak(str, pos - 2, includeExtending);
     if (found < pos) return found
     pos--;
@@ -5797,10 +5797,18 @@ class SelectionRange {
     /**
     The upper boundary of the range.
     */
-    to, flags) {
+    to, flags, 
+    /**
+    The goal column (stored vertical offset) associated with a
+    cursor. This is used to preserve the vertical position when
+    [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across
+    lines of different length.
+    */
+    goalColumn) {
         this.from = from;
         this.to = to;
         this.flags = flags;
+        this.goalColumn = goalColumn;
     }
     /**
     The anchor of the range—the side that doesn't move when you
@@ -5824,6 +5832,16 @@ class SelectionRange {
     */
     get assoc() { return this.flags & 8 /* RangeFlag.AssocBefore */ ? -1 : this.flags & 16 /* RangeFlag.AssocAfter */ ? 1 : 0; }
     /**
+    A flag that, when set, makes some selection-extending commands
+    treat the range's head and anchor as exchangeable, so that for
+    example Shift-ArrowUp will make the lower side of the selection
+    the anchor, even if that was the head before. Used to implement
+    MacOS-style undirectional selections.
+    */
+    get undirectional() {
+        return (this.flags & 64 /* RangeFlag.Undirectional */) > 0;
+    }
+    /**
     The bidirectional text level associated with this cursor, if
     any.
     */
@@ -5832,16 +5850,6 @@ class SelectionRange {
         return level == 7 ? null : level;
     }
     /**
-    The goal column (stored vertical offset) associated with a
-    cursor. This is used to preserve the vertical position when
-    [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across
-    lines of different length.
-    */
-    get goalColumn() {
-        let value = this.flags >> 6 /* RangeFlag.GoalColumnOffset */;
-        return value == 16777215 /* RangeFlag.NoGoalColumn */ ? undefined : value;
-    }
-    /**
     Map this range through a change, producing a valid range in the
     updated document.
     */
@@ -5854,7 +5862,7 @@ class SelectionRange {
             from = change.mapPos(this.from, 1);
             to = change.mapPos(this.to, -1);
         }
-        return from == this.from && to == this.to ? this : new SelectionRange(from, to, this.flags);
+        return from == this.from && to == this.to ? this : new SelectionRange(from, to, this.flags, this.goalColumn);
     }
     /**
     Extend this range to cover at least `from` to `to`.
@@ -5888,8 +5896,8 @@ class SelectionRange {
     /**
     @internal
     */
-    static create(from, to, flags) {
-        return new SelectionRange(from, to, flags);
+    static create(from, to, flags, goalColumn) {
+        return new SelectionRange(from, to, flags, goalColumn);
     }
 }
 /**
@@ -6004,19 +6012,26 @@ class EditorSelection {
     */
     static cursor(pos, assoc = 0, bidiLevel, goalColumn) {
         return SelectionRange.create(pos, pos, (assoc == 0 ? 0 : assoc < 0 ? 8 /* RangeFlag.AssocBefore */ : 16 /* RangeFlag.AssocAfter */) |
-            (bidiLevel == null ? 7 : Math.min(6, bidiLevel)) |
-            ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 16777215 /* RangeFlag.NoGoalColumn */) << 6 /* RangeFlag.GoalColumnOffset */));
+            (bidiLevel == null ? 7 : Math.min(6, bidiLevel)), goalColumn);
     }
     /**
     Create a selection range.
     */
     static range(anchor, head, goalColumn, bidiLevel, assoc) {
-        let flags = ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 16777215 /* RangeFlag.NoGoalColumn */) << 6 /* RangeFlag.GoalColumnOffset */) |
-            (bidiLevel == null ? 7 : Math.min(6, bidiLevel));
+        let flags = bidiLevel == null ? 7 : Math.min(6, bidiLevel);
         if (!assoc && anchor != head)
             assoc = head < anchor ? 1 : -1;
-        return head < anchor ? SelectionRange.create(head, anchor, 32 /* RangeFlag.Inverted */ | 16 /* RangeFlag.AssocAfter */ | flags)
-            : SelectionRange.create(anchor, head, (!assoc ? 0 : assoc < 0 ? 8 /* RangeFlag.AssocBefore */ : 16 /* RangeFlag.AssocAfter */) | flags);
+        if (assoc)
+            flags |= assoc < 0 ? 8 /* RangeFlag.AssocBefore */ : 16 /* RangeFlag.AssocAfter */;
+        return head < anchor ? SelectionRange.create(head, anchor, flags | 32 /* RangeFlag.Inverted */, goalColumn)
+            : SelectionRange.create(anchor, head, flags, goalColumn);
+    }
+    /**
+    Create an [undirectional](https://codemirror.net/6/docs/ref/#state.SelectionRange.undirectional)
+    selection range.
+    */
+    static undirectionalRange(from, to) {
+        return SelectionRange.create(from, to, 64 /* RangeFlag.Undirectional */, undefined);
     }
     /**
     @internal
@@ -6188,6 +6203,7 @@ class FacetProvider {
             }
         };
     }
+    get extension() { return this; }
 }
 function compareArray(a, b, compare) {
     if (a.length != b.length)
@@ -6385,6 +6401,7 @@ class PrecExtension {
         this.inner = inner;
         this.prec = prec;
     }
+    get extension() { return this; }
 }
 /**
 Extension compartments can be used to make a configuration
@@ -6419,6 +6436,7 @@ class CompartmentInstance {
         this.compartment = compartment;
         this.inner = inner;
     }
+    get extension() { return this; }
 }
 class Configuration {
     constructor(base, compartments, dynamicSlots, address, staticValues, facets) {
@@ -6528,6 +6546,8 @@ function flatten(extension, compartments, newCompartments) {
         else {
             let content = ext.extension;
             if (!content)
+                throw new Error(`Unrecognized extension value in extension set (${ext}).`);
+            if (content == ext)
                 throw new Error(`Unrecognized extension value in extension set (${ext}). This sometimes happens because multiple instances of @codemirror/state are loaded, breaking instanceof checks.`);
             inner(content, prec);
         }
@@ -11521,10 +11541,12 @@ class TileUpdate {
                     }
                     pendingLineAttrs = null;
                 }
+                markCount = active.length;
             }
         });
-        b.addLineStartIfNotCovered(pendingLineAttrs);
         this.openWidget = openEnd > markCount;
+        if (!this.openWidget)
+            b.addLineStartIfNotCovered(pendingLineAttrs);
         this.openMarks = openEnd;
     }
     forward(from, to, side = 1) {
@@ -12349,7 +12371,7 @@ function groupAt(state, pos, bias = 1) {
             break;
         to = next;
     }
-    return EditorSelection.range(from + line.from, to + line.from);
+    return EditorSelection.undirectionalRange(from + line.from, to + line.from);
 }
 function posAtCoordsImprecise(view, contentRect, block, x, y) {
     let into = Math.round((x - contentRect.left) * view.defaultCharacterWidth);
@@ -12486,8 +12508,12 @@ function skipAtomsForSelection(atoms, sel) {
         else {
             let from = skipAtomicRanges(atoms, range.from, -1);
             let to = skipAtomicRanges(atoms, range.to, 1);
-            if (from != range.from || to != range.to)
-                updated = EditorSelection.range(range.from == range.anchor ? from : to, range.from == range.head ? from : to);
+            if (from != range.from || to != range.to) {
+                if (range.undirectional)
+                    updated = EditorSelection.undirectionalRange(range.from, range.to);
+                else
+                    updated = EditorSelection.range(range.from == range.anchor ? from : to, range.from == range.head ? from : to);
+            }
         }
         if (updated) {
             if (!ranges)
@@ -12893,7 +12919,8 @@ class DOMChange {
             // Chrome will put the selection *inside* them, confusing
             // posFromDOM
             let vp = view.viewport;
-            if ((browser.ios || browser.chrome) && curSel.main.empty && head != anchor &&
+            if ((browser.ios || browser.chrome) && head != anchor &&
+                Math.min(head, anchor) <= curSel.main.from && Math.max(head, anchor) >= curSel.main.to &&
                 (vp.from > 0 || vp.to < view.state.doc.length)) {
                 let from = Math.min(head, anchor), to = Math.max(head, anchor);
                 let offFrom = vp.from - from, offTo = vp.to - to;
@@ -13214,13 +13241,11 @@ class InputState {
         // (after which we retroactively handle them and reset the DOM) to
         // avoid messing up the virtual keyboard state.
         this.pendingIOSKey = undefined;
-        /**
-        When enabled (>-1), tab presses are not given to key handlers,
-        leaving the browser's default behavior. If >0, the mode expires
-        at that timestamp, and any other keypress clears it.
-        Esc enables temporary tab focus mode for two seconds when not
-        otherwise handled.
-        */
+        // When enabled (>-1), tab presses are not given to key handlers,
+        // leaving the browser's default behavior. If >0, the mode expires
+        // at that timestamp, and any other keypress clears it.
+        // Esc enables temporary tab focus mode for two seconds when not
+        // otherwise handled.
         this.tabFocusMode = -1;
         this.lastSelectionOrigin = null;
         this.lastSelectionTime = 0;
@@ -13328,11 +13353,16 @@ class InputState {
         // state. So we let it go through, and then, in
         // applyDOMChange, notify key handlers of it and reset to
         // the state they produce.
-        let pending;
-        if (browser.ios && !event.synthetic && !event.altKey && !event.metaKey && !event.shiftKey &&
-            ((pending = PendingKeys.find(key => key.keyCode == event.keyCode)) && !event.ctrlKey ||
+        if (browser.ios && !event.synthetic && !event.altKey && !event.metaKey &&
+            (PendingKeys.some(key => key.keyCode == event.keyCode) && !event.ctrlKey ||
                 EmacsyPendingKeys.indexOf(event.key) > -1 && event.ctrlKey)) {
-            this.pendingIOSKey = pending || event;
+            let mods = { ctrlKey: event.ctrlKey, altKey: event.altKey, metaKey: event.metaKey, shiftKey: event.shiftKey };
+            // On iOS with autocapitalize, drop the shift modifier for these
+            // keys, since it will be set at the start of every sentence.
+            if (mods.shiftKey && browser.ios && !/^(off|none)$/.test(this.view.contentDOM.autocapitalize) &&
+                iosVirtualKeyboardOpen(this.view.win))
+                mods.shiftKey = false;
+            this.pendingIOSKey = { key: event.key, keyCode: event.keyCode, mods };
             setTimeout(() => this.flushIOSKey(), 250);
             return true;
         }
@@ -13348,7 +13378,7 @@ class InputState {
         if (key.key == "Enter" && change && change.from < change.to && /^\S+$/.test(change.insert.toString()))
             return false;
         this.pendingIOSKey = undefined;
-        return dispatchKey(this.view.contentDOM, key.key, key.keyCode, key instanceof KeyboardEvent ? key : undefined);
+        return dispatchKey(this.view.contentDOM, key.key, key.keyCode, key.mods);
     }
     ignoreDuringComposition(event) {
         if (!/^key/.test(event.type) || event.synthetic)
@@ -13386,6 +13416,11 @@ class InputState {
             this.mouseSelection.destroy();
     }
 }
+function iosVirtualKeyboardOpen(win) {
+    if (!win.visualViewport)
+        return false;
+    return win.visualViewport.height * win.visualViewport.scale / win.document.documentElement.clientHeight < 0.85;
+}
 function bindHandler(plugin, handler) {
     return (view, event) => {
         try {
@@ -13705,7 +13740,7 @@ function rangeForClick(view, pos, bias, type) {
         let from = visual ? visual.posAtStart : line.from, to = visual ? visual.posAtEnd : line.to;
         if (to < view.state.doc.length && to == line.to)
             to++;
-        return EditorSelection.range(from, to);
+        return EditorSelection.undirectionalRange(from, to);
     }
 }
 const BadMouseDetail = browser.ie && browser.ie_version <= 11;
@@ -13763,7 +13798,7 @@ handlers.dragstart = (view, event) => {
         if (tile && tile.isWidget()) {
             let from = tile.posAtStart, to = from + tile.length;
             if (from >= range.to || to <= range.from)
-                range = EditorSelection.range(from, to);
+                range = EditorSelection.undirectionalRange(from, to);
         }
     }
     let { inputState } = view;
@@ -16388,7 +16423,6 @@ class EditContextManager {
         for (let event in this.handlers)
             context.addEventListener(event, this.handlers[event]);
         this.measureReq = { read: view => {
-                this.editContext.updateControlBounds(view.contentDOM.getBoundingClientRect());
                 let sel = getSelection(view.root);
                 if (sel && sel.rangeCount)
                     this.editContext.updateSelectionBounds(sel.getRangeAt(0).getBoundingClientRect());
@@ -20524,8 +20558,7 @@ function topNodeAt(state, pos, side) {
 }
 /**
 A subclass of [`Language`](https://codemirror.net/6/docs/ref/#language.Language) for use with Lezer
-[LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser)
-parsers.
+[LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser).
 */
 class LRLanguage extends Language {
     constructor(data, parser, name) {
@@ -21498,18 +21531,25 @@ const foldState = /*@__PURE__*/StateField.define({
         if (tr.isUserEvent("delete"))
             tr.changes.iterChangedRanges((fromA, toA) => folded = clearTouchedFolds(folded, fromA, toA));
         folded = folded.map(tr.changes);
+        let rangesToFold = [];
         for (let e of tr.effects) {
             if (e.is(foldEffect) && !foldExists(folded, e.value.from, e.value.to)) {
-                let { preparePlaceholder } = tr.state.facet(foldConfig);
-                let widget = !preparePlaceholder ? foldWidget :
-                    Decoration.replace({ widget: new PreparedFoldWidget(preparePlaceholder(tr.state, e.value)) });
-                folded = folded.update({ add: [widget.range(e.value.from, e.value.to)] });
+                rangesToFold.push(e.value);
             }
             else if (e.is(unfoldEffect)) {
                 folded = folded.update({ filter: (from, to) => e.value.from != from || e.value.to != to,
                     filterFrom: e.value.from, filterTo: e.value.to });
             }
         }
+        if (rangesToFold.length) {
+            let { preparePlaceholder } = tr.state.facet(foldConfig);
+            let decorations = rangesToFold.map(value => {
+                let widget = !preparePlaceholder ? foldWidget :
+                    Decoration.replace({ widget: new PreparedFoldWidget(preparePlaceholder(tr.state, value)) });
+                return widget.range(value.from, value.to);
+            });
+            folded = folded.update({ add: decorations });
+        }
         // Clear folded ranges that cover the selection head
         if (tr.selection)
             folded = clearTouchedFolds(folded, tr.selection.main.head);
@@ -21825,7 +21865,7 @@ class HighlightStyle {
     or array of tags in their `tag` property, and either a single
     `class` property providing a static CSS class (for highlighter
     that rely on external styling), or a
-    [`style-mod`](https://github.com/marijnh/style-mod#documentation)-style
+    [`style-mod`](https://code.haverbeke.berlin/marijn/style-mod#documentation)-style
     set of CSS properties (which define the styling for those tags).
     
     The CSS rules created for a highlighter will be emitted in the
@@ -23038,8 +23078,10 @@ Move the selection to the bracket matching the one it is currently
 on, if any.
 */
 const cursorMatchingBracket = ({ state, dispatch }) => toMatchingBracket(state, dispatch);
-function extendSel(target, how) {
+function extendSel(target, forward, how) {
     let selection = updateSel(target.state.selection, range => {
+        if (range.undirectional && (range.head >= range.anchor) != forward)
+            range = EditorSelection.range(range.head, range.anchor);
         let head = how(range);
         return EditorSelection.range(range.anchor, head.head, head.goalColumn, head.bidiLevel || undefined, head.assoc);
     });
@@ -23049,7 +23091,7 @@ function extendSel(target, how) {
     return true;
 }
 function selectByChar(view, forward) {
-    return extendSel(view, range => view.moveByChar(range, forward));
+    return extendSel(view, forward, range => view.moveByChar(range, forward));
 }
 /**
 Move the selection head one character to the left, while leaving
@@ -23061,7 +23103,7 @@ Move the selection head one character to the right.
 */
 const selectCharRight = view => selectByChar(view, ltrAtCursor(view));
 function selectByGroup(view, forward) {
-    return extendSel(view, range => view.moveByGroup(range, forward));
+    return extendSel(view, forward, range => view.moveByGroup(range, forward));
 }
 /**
 Move the selection head one [group](https://codemirror.net/6/docs/ref/#commands.cursorGroupLeft) to
@@ -23075,13 +23117,19 @@ const selectGroupRight = view => selectByGroup(view, ltrAtCursor(view));
 /**
 Move the selection head over the next syntactic element to the left.
 */
-const selectSyntaxLeft = view => extendSel(view, range => moveBySyntax(view.state, range, !ltrAtCursor(view)));
+const selectSyntaxLeft = view => {
+    let forward = !ltrAtCursor(view);
+    return extendSel(view, forward, range => moveBySyntax(view.state, range, forward));
+};
 /**
 Move the selection head over the next syntactic element to the right.
 */
-const selectSyntaxRight = view => extendSel(view, range => moveBySyntax(view.state, range, ltrAtCursor(view)));
+const selectSyntaxRight = view => {
+    let forward = ltrAtCursor(view);
+    return extendSel(view, forward, range => moveBySyntax(view.state, range, forward));
+};
 function selectByLine(view, forward) {
-    return extendSel(view, range => view.moveVertically(range, forward));
+    return extendSel(view, forward, range => view.moveVertically(range, forward));
 }
 /**
 Move the selection head one line up.
@@ -23092,7 +23140,7 @@ Move the selection head one line down.
 */
 const selectLineDown = view => selectByLine(view, true);
 function selectByPage(view, forward) {
-    return extendSel(view, range => view.moveVertically(range, forward, pageInfo(view).height));
+    return extendSel(view, forward, range => view.moveVertically(range, forward, pageInfo(view).height));
 }
 /**
 Move the selection head one page up.
@@ -23105,27 +23153,33 @@ const selectPageDown = view => selectByPage(view, true);
 /**
 Move the selection head to the next line boundary.
 */
-const selectLineBoundaryForward = view => extendSel(view, range => moveByLineBoundary(view, range, true));
+const selectLineBoundaryForward = view => extendSel(view, true, range => moveByLineBoundary(view, range, true));
 /**
 Move the selection head to the previous line boundary.
 */
-const selectLineBoundaryBackward = view => extendSel(view, range => moveByLineBoundary(view, range, false));
+const selectLineBoundaryBackward = view => extendSel(view, false, range => moveByLineBoundary(view, range, false));
 /**
 Move the selection head one line boundary to the left.
 */
-const selectLineBoundaryLeft = view => extendSel(view, range => moveByLineBoundary(view, range, !ltrAtCursor(view)));
+const selectLineBoundaryLeft = view => {
+    let forward = !ltrAtCursor(view);
+    return extendSel(view, forward, range => moveByLineBoundary(view, range, forward));
+};
 /**
 Move the selection head one line boundary to the right.
 */
-const selectLineBoundaryRight = view => extendSel(view, range => moveByLineBoundary(view, range, ltrAtCursor(view)));
+const selectLineBoundaryRight = view => {
+    let forward = ltrAtCursor(view);
+    return extendSel(view, forward, range => moveByLineBoundary(view, range, forward));
+};
 /**
 Move the selection head to the start of the line.
 */
-const selectLineStart = view => extendSel(view, range => EditorSelection.cursor(view.lineBlockAt(range.head).from));
+const selectLineStart = view => extendSel(view, false, range => EditorSelection.cursor(view.lineBlockAt(range.head).from));
 /**
 Move the selection head to the end of the line.
 */
-const selectLineEnd = view => extendSel(view, range => EditorSelection.cursor(view.lineBlockAt(range.head).to));
+const selectLineEnd = view => extendSel(view, true, range => EditorSelection.cursor(view.lineBlockAt(range.head).to));
 /**
 Move the selection to the start of the document.
 */

package/dist/server/static/web-socket.js

@@ -0,0 +1,41 @@
+import apiConstructor from '../api.js'
+
+const api = apiConstructor()
+
+// Create WebSocket connection.
+const socket = new WebSocket('ws://localhost:8974')
+
+// Connection opened
+socket.addEventListener('open', () => {
+  console.log('Watching for Blueprint changes')
+})
+
+// Listen for messages
+socket.addEventListener('message', (event) => {
+  if (event.data === 'reload-blueprint') {
+    api.blueprint()
+    return
+  }
+
+  let message
+  try {
+    message = JSON.parse(event.data)
+  } catch {
+    return
+  }
+
+  if (message?.type === 'nested-invoke') {
+    window.dispatchEvent(
+      new CustomEvent('nested-invoke', {
+        detail: {
+          name: message.name,
+          order: message.order,
+          logs: message.logs,
+          json: message.json,
+          error: message.error,
+          timings: message.timings,
+        },
+      }),
+    )
+  }
+})

package/dist/utils/functions/child-process-wrapper.js

@@ -76,7 +76,34 @@ console.error = (...args) => {
   process.stdout.write(`${logPrefix('error', ...args)}\n`)
 }
 
-// Start when payload data arrives from parent process
+/**
+ * Pending nested `context.invoke` calls, keyed by correlation id. Each entry
+ * holds the resolve/reject of the Promise returned to the user's handler; it is
+ * settled when the matching `invoke-response` arrives from the parent.
+ * @type {Map<string, {resolve: (value: unknown) => void, reject: (reason: Error) => void}>}
+ */
+const pendingInvokes = new Map()
+let invokeSeq = 0
+
+/**
+ * `context.invoke(name, payload)` — ask the parent to execute another blueprint
+ * function and resolve with its return value. Sent over IPC and correlated by id.
+ * @param {string} name
+ * @param {Record<string, unknown>} [payload]
+ * @returns {Promise<unknown>}
+ */
+function invokeFunction(name, payload = {}) {
+  if (typeof name !== 'string' || name.length === 0) {
+    return Promise.reject(new Error('context.invoke requires a function name'))
+  }
+  const id = String(++invokeSeq)
+  return new Promise((resolve, reject) => {
+    pendingInvokes.set(id, {resolve, reject})
+    process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
+  })
+}
+
+// Listen for IPC messages from the parent process.
 process.on('message', async (data) => {
   let jsonData = null
   try {
@@ -86,6 +113,25 @@ process.on('message', async (data) => {
     return
   }
 
+  // Response to a nested context.invoke() — route to the awaiting Promise and stop.
+  if (jsonData?.type === 'invoke-response') {
+    const pending = pendingInvokes.get(jsonData.id)
+    if (!pending) return
+    pendingInvokes.delete(jsonData.id)
+    if (jsonData.ok) {
+      pending.resolve(jsonData.result?.json)
+    } else {
+      const {message, stack, name} = jsonData.error ?? {}
+      const error = new Error(message ?? 'Nested invoke failed')
+      if (stack) error.stack = stack
+      if (name) error.name = name
+      pending.reject(error)
+    }
+    return
+  }
+
+  // Otherwise this is the initial start message. Support the legacy untyped
+  // `{srcPath, payload}` shape as well as the new `{type: 'start', ...}`.
   const {srcPath, payload} = jsonData
   const {context, ...event} = payload
 
@@ -93,17 +139,22 @@ process.on('message', async (data) => {
   let errorLogs = ''
   let json = null
 
-  // Capture stdout and stderr
+  // Capture stdout and stderr in-memory for the terminal `result` message, and
+  // ALSO send them through to the real stdio pipes. The parent captures those
+  // pipes live, so logs written before a timeout (child killed) or a
+  // process.exit() aren't lost
   const originalStdoutWrite = process.stdout.write.bind(process.stdout)
   const originalStderrWrite = process.stderr.write.bind(process.stderr)
 
-  process.stdout.write = (chunk) => {
+  process.stdout.write = (...args) => {
+    const chunk = args[0]
     if (typeof chunk === 'string') logs += chunk
-    return true
+    return originalStdoutWrite(...args)
   }
-  process.stderr.write = (chunk) => {
+  process.stderr.write = (...args) => {
+    const chunk = args[0]
     if (typeof chunk === 'string') errorLogs += chunk
-    return true
+    return originalStderrWrite(...args)
   }
 
   try {
@@ -120,6 +171,9 @@ process.on('message', async (data) => {
     // Replace resources JSON with Resources API
     context.resources = createResourcesApi(context.resources)
 
+    // Allow the handler to invoke other blueprint functions by name.
+    context.invoke = invokeFunction
+
     json = await eventHandler({
       context,
       event,
@@ -132,13 +186,14 @@ process.on('message', async (data) => {
     process.stderr.write = originalStderrWrite
 
     // Send result to parent
-    process.send(JSON.stringify({json, logs, errorLogs}))
+    process.send(JSON.stringify({type: 'result', json, logs, errorLogs}))
   } catch (err) {
     // Restore streams on error
     process.stdout.write = originalStdoutWrite
     process.stderr.write = originalStderrWrite
 
     const errorInfo = {
+      type: 'result',
       json: null,
       logs,
       errorLogs,

package/dist/utils/functions/find-entry-point.d.ts

@@ -8,4 +8,4 @@
  * @returns The absolute path to the entry file.
  * @throws If the entry file cannot be determined.
  */
-export declare function findFunctionEntryPoint(srcPath: string, displayName?: string): Promise<string>;
+export declare function findFunctionEntryPoint(functionPath: string, displayName?: string): Promise<string>;

package/dist/utils/functions/find-entry-point.js

@@ -1,6 +1,5 @@
 import { readFile, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { cwd } from 'node:process';
 /**
  * Resolves the source path to an executable entry file path.
  *
@@ -11,27 +10,26 @@ import { cwd } from 'node:process';
  * @returns The absolute path to the entry file.
  * @throws If the entry file cannot be determined.
  */
-export async function findFunctionEntryPoint(srcPath, displayName) {
-    const absolutePath = resolve(cwd(), srcPath);
+export async function findFunctionEntryPoint(functionPath, displayName) {
     let stats;
     try {
-        stats = await stat(absolutePath);
+        stats = await stat(functionPath);
     }
     catch (err) {
-        throw new Error(`Source path not found or inaccessible: ${srcPath}`, { cause: err });
+        throw new Error(`Source path not found or inaccessible: ${functionPath}`, { cause: err });
     }
     if (stats.isFile()) {
         // It's already an entry file path
-        return absolutePath;
+        return functionPath;
     }
     if (stats.isDirectory()) {
         // 1. Check package.json#main
         try {
-            const pkgJsonPath = join(absolutePath, 'package.json');
+            const pkgJsonPath = join(functionPath, 'package.json');
             const pkgJsonContent = await readFile(pkgJsonPath, 'utf8');
             const pkgJson = JSON.parse(pkgJsonContent);
             if (pkgJson.main) {
-                const mainPath = resolve(absolutePath, pkgJson.main);
+                const mainPath = resolve(functionPath, pkgJson.main);
                 if (await fileExists(mainPath)) {
                     return mainPath;
                 }
@@ -43,20 +41,20 @@ export async function findFunctionEntryPoint(srcPath, displayName) {
             // Consider warning the user on invalid JSON though?
         }
         // 2. Check index.ts
-        const indexTs = join(absolutePath, 'index.ts');
+        const indexTs = join(functionPath, 'index.ts');
         if (await fileExists(indexTs)) {
             return indexTs;
         }
         // 3. Check index.js
-        const indexJs = join(absolutePath, 'index.js');
+        const indexJs = join(functionPath, 'index.js');
         if (await fileExists(indexJs)) {
             return indexJs;
         }
         const nameHint = displayName ? ` for function "${displayName}"` : '';
-        throw new Error(`Could not determine entry file${nameHint} in directory: ${srcPath}. Looked for package.json#main, index.ts, index.js.`);
+        throw new Error(`Could not determine entry file${nameHint} in directory: ${functionPath}. Looked for package.json#main, index.ts, index.js.`);
     }
     // Should not happen if stat succeeded, but defensively handle
-    throw new Error(`Source path is neither a file nor a directory: ${srcPath}`);
+    throw new Error(`Source path is neither a file nor a directory: ${functionPath}`);
 }
 /**
  * Checks if a file exists and is a file.

package/dist/utils/functions/{invoke-local.d.ts → invoke/local.d.ts}

@@ -1,4 +1,4 @@
-import { type FunctionGroqResource, type FunctionResource, type InvocationResponse, type InvokeContextOptions, type InvokeExecutionOptions, type InvokeGroqPayloadOptions, type InvokePayloadOptions } from '../types.js';
+import { type FunctionGroqResource, type FunctionResource, type InvocationResponse, type InvokeContextOptions, type InvokeExecutionOptions, type InvokeGroqPayloadOptions, type InvokePayloadOptions } from '../../types.js';
 export declare function sanitizeLogs(logs: string): string;
 export declare function applyGroqRule(resource: FunctionGroqResource, payload: InvokeGroqPayloadOptions, projectId: string | undefined, dataset: string | undefined): Promise<any>;
 export default function invoke(resource: FunctionResource, payload: InvokePayloadOptions, context: InvokeContextOptions, options: InvokeExecutionOptions): Promise<InvocationResponse>;