@sanity/runtime-cli 11.0.4 → 11.1.1

package/dist/server/static/api.js

@@ -14,6 +14,9 @@ export default function API() {
     invoke,
     projects,
     datasets,
+    organizations,
+    mediaLibraries,
+    asset,
     store,
     subscribe: store.subscribe,
     unsubscribe: store.unsubscribe,
@@ -52,14 +55,16 @@ function blueprint() {
   fetch('/blueprint')
     .then((response) => response.json())
     .then((blueprint) => {
-      const {parsedBlueprint, projectId} = blueprint
+      const {parsedBlueprint, projectId, organizationId} = blueprint
       const functions = parsedBlueprint?.resources.filter((r) =>
         r.type.startsWith('sanity.function.'),
       )
 
       store.functions = functions
       store.selectedIndex = functions[0].name
+      store.selectedFunctionType = functions[0].type
       store.defaultProject = projectId || undefined
+      store.defaultOrganization = organizationId || undefined
     })
     .catch(() => {
       store.functions = []
@@ -69,9 +74,10 @@ function blueprint() {
 function projects() {
   fetch('/projects')
     .then((response) => response.json())
-    .then((projects) => {
+    .then(async (projects) => {
       store.projects = projects
       store.selectedProject = store.defaultProject ? store.defaultProject : projects[0].id
+      await datasets(store.selectedProject)
     })
     .catch(() => {
       store.projects = []
@@ -101,6 +107,46 @@ function document({projectId, dataset, docId}) {
     })
 }
 
+function organizations() {
+  fetch('/organizations')
+    .then((response) => response.json())
+    .then(async (organizations) => {
+      store.organizations = organizations
+      store.selectedOrganization = store.defaultOrganization
+        ? store.defaultOrganization
+        : organizations[0].id
+      await mediaLibraries(store.selectedOrganization)
+    })
+    .catch(() => {
+      store.organizations = []
+    })
+}
+
+function mediaLibraries(selectedOrganization) {
+  fetch(`/media-libraries?organization=${selectedOrganization}`)
+    .then((response) => response.json())
+    .then((mediaLibraries) => {
+      store.mediaLibraries = mediaLibraries
+      store.selectedMediaLibrary = store.defaultMediaLibrary
+        ? store.defaultMediaLibrary
+        : mediaLibraries[0].id
+    })
+    .catch(() => {
+      store.mediaLibraries = []
+    })
+}
+
+function asset({organizationId, mediaLibraryId, docId}) {
+  return fetch(`/asset?organization=${organizationId}&medialibrary=${mediaLibraryId}&doc=${docId}`)
+    .then((response) => response.json())
+    .then((doc) => {
+      store.document = doc
+    })
+    .catch(() => {
+      store.document = {}
+    })
+}
+
 function getServerTimings(response) {
   const timings = {}
   const serverTiming = response.headers.get('Server-Timing')

package/dist/server/static/components/app.css

@@ -678,9 +678,15 @@ body {
 }
 
 /* Utilities */
+.capitalize {
+  text-transform: capitalize;
+}
 .flex {
   display: flex;
 }
+.flex-column {
+  flex-direction: column;
+}
 .items-center {
   align-items: center;
 }
@@ -986,7 +992,6 @@ footer {
 }
 
 .function-list-item {
-  color: light-dark(var(--gray-800), var(--gray-400));
   padding: 8px;
   font-size: 0.875rem;
   border-radius: 3px;
@@ -994,6 +999,16 @@ footer {
   cursor: pointer;
 }
 
+.function-list-item-label {
+  color: light-dark(var(--gray-800), var(--gray-400));
+  font-weight: var(--font-weight-3);
+  padding-bottom: var(--space-1);
+}
+
+.function-list-item-type {
+  color: light-dark(var(--gray-900), var(--gray-300));
+}
+
 .dropdown-select {
   background: transparent;
   color: light-dark(var(--gray-950), var(--gray-300));

package/dist/server/static/components/fetch-button.js

@@ -63,11 +63,20 @@ export class FetchButton extends ApiBaseElement {
       this.button.innerHTML = '<network-spinner></network-spinner>'
 
       try {
-        await this.api.document({
-          projectId: this.api.store.selectedProject,
-          dataset: this.api.store.selectedDataset,
-          docId,
-        })
+        // TODO: This assumes only two functions types for the sake of releasing today
+        if (this.api.store.selectedFunctionType === 'sanity.function.document') {
+          await this.api.document({
+            projectId: this.api.store.selectedProject,
+            dataset: this.api.store.selectedDataset,
+            docId,
+          })
+        } else {
+          await this.api.asset({
+            organizationId: this.api.store.selectedOrganization,
+            mediaLibraryId: this.api.store.selectedMediaLibrary,
+            docId,
+          })
+        }
       } catch (err) {
         console.error('Error fetching document:', err)
       } finally {

package/dist/server/static/components/filter-api-version.js

@@ -0,0 +1,14 @@
+class ApiVersionComponent extends HTMLElement {
+  connectedCallback() {
+    this.innerHTML = `
+<fieldset class="mar-t-sm">
+    <label class="slab-text">
+      <span style="display: block; margin-bottom: var(--space-1);">API Version</span>
+      <input name="apiVersion" id="apiversion" style="background: transparent; border-color: light-dark(var(--gray-200), var(--gray-700)); height: 2.5rem; color: light-dark(var(--gray-950), var(--gray-300));">
+    </label>
+</fieldset>
+`
+  }
+}
+
+customElements.define('api-version', ApiVersionComponent)

package/dist/server/static/components/filter-document-id.js

@@ -0,0 +1,26 @@
+class DocumentIdFilter extends HTMLElement {
+  connectedCallback() {
+    this.innerHTML = `
+<fieldset class="mar-t-sm" style="margin-top: 12px !important;">
+    <label class="slab-text">
+      <span style="display: block; margin-bottom: var(--space-1);">
+        <span style="display: flex; align-items: center;">
+          Document ID
+          <help-button>
+            <p>Fill out "Document ID" text field and then click the "Fetch Document" button to pre-populate the Document panel.</p>
+            <p>The Document panel is an editable text field so you can edit the fetched document or replace it with any JSON data you want.</p>
+            <p>When you click the "Run" button the contents of the Document panel will be evaluated against your filter/projection and sent to your function as the event part of the payload.</p>
+          </help-button>
+        </span>
+      </span>
+      <div style="display: flex; flex-direction: row; gap: var(--space-2);">
+        <input name="docid" id="docid" style="background: transparent; border-color: light-dark(var(--gray-200), var(--gray-700)); height: 2.5rem; color: light-dark(var(--gray-950), var(--gray-300));">
+        <fetch-button></fetch-button>
+      </div>
+    </label>
+</fieldset>
+`
+  }
+}
+
+customElements.define('document-id', DocumentIdFilter)

package/dist/server/static/components/filter-with-token.js

@@ -0,0 +1,21 @@
+class WithTokenComponent extends HTMLElement {
+  connectedCallback() {
+    this.innerHTML = `
+<fieldset class="mar-t-sm" style="display: flex; flex-direction: column; margin-top: 12px !important;">
+    <span class="slab-text" style="display: block; margin-bottom: var(--space-1);">
+        <span style="display: flex; align-items: center;">
+        With Token
+        <help-button>
+            <p><strong>With Token</strong> controls whether your function runs with or without authentication.</p>
+            <p><strong>Enabled:</strong> Function executes with your API token, providing full, authenticated access to your Sanity project.</p>
+            <p><strong>Disabled:</strong> Function executes without authentication, useful for testing public endpoints or functions that don't require user permissions.</p>
+        </help-button>
+        </span>
+    </span>
+    <toggle-switch toggle-key="withToken" style="display: flex; height: 2.5rem;"></toggle-switch>
+</fieldset>
+`
+  }
+}
+
+customElements.define('with-token', WithTokenComponent)

package/dist/server/static/components/filters.js

@@ -1,10 +1,19 @@
-class FiltersComponent extends HTMLElement {
-  connectedCallback() {
+import {ApiBaseElement} from './api-base.js'
+
+class FiltersComponent extends ApiBaseElement {
+  renderFilters = () => {
+    const docFunction = this.api.store.selectedFunctionType === 'sanity.function.document'
+    const mediaFunction = this.api.store.selectedFunctionType?.startsWith(
+      'sanity.function.media-library',
+    )
+
     this.innerHTML = `
         <form style="gap: 8px; padding-left: var(--space-3); padding-bottom: var(--space-3); border-bottom: 1px solid var(--card-border-color);">
           <fieldset style="display: flex; gap: var(--space-2);">
             <legend class="config-label">Client Options</legend>
-            <select-dropdown
+            ${
+              docFunction
+                ? `<select-dropdown
               label="Project"
               store-key="projects"
               selected-key="selectedProject"
@@ -19,7 +28,30 @@ class FiltersComponent extends HTMLElement {
               value-prop="name"
               label-prop="name"
               subscribe-to="selectedProject"
+            ></select-dropdown>`
+                : ''
+            }
+            ${
+              mediaFunction
+                ? `<select-dropdown
+              label="Organization"
+              store-key="organizations"
+              selected-key="selectedOrganization"
+              value-prop="id"
+              label-prop="name"
+              trigger-fetch
             ></select-dropdown>
+            <select-dropdown
+              label="Media Library"
+              store-key="mediaLibraries"
+              selected-key="selectedMediaLibrary"
+              value-prop="id"
+              label-prop="id"
+              subscribe-to="selectedOrganization"
+            ></select-dropdown>`
+                : ''
+            }
+
             <select-dropdown
               label="Event"
               store-key="events"
@@ -27,49 +59,22 @@ class FiltersComponent extends HTMLElement {
               value-prop="name"
               label-prop="name"
             ></select-dropdown>
-            <fieldset class="mar-t-sm">
-                <label class="slab-text">
-                  <span style="display: block; margin-bottom: var(--space-1);">API Version</span>
-                  <input name="apiVersion" id="apiversion" style="background: transparent; border-color: light-dark(var(--gray-200), var(--gray-700)); height: 2.5rem; color: light-dark(var(--gray-950), var(--gray-300));">
-                </label>
-            </fieldset>
-
-            <fieldset class="mar-t-sm" style="display: flex; flex-direction: column; margin-top: 12px !important;">
-                <span class="slab-text" style="display: block; margin-bottom: var(--space-1);">
-                  <span style="display: flex; align-items: center;">
-                    With Token 
-                    <help-button>
-                      <p><strong>With Token</strong> controls whether your function runs with or without authentication.</p>
-                      <p><strong>Enabled:</strong> Function executes with your API token, providing full, authenticated access to your Sanity project.</p>
-                      <p><strong>Disabled:</strong> Function executes without authentication, useful for testing public endpoints or functions that don't require user permissions.</p>
-                    </help-button>
-                  </span>
-                </span>
-                <toggle-switch toggle-key="withToken" style="display: flex; height: 2.5rem;"></toggle-switch>
-            </fieldset>
-
-            <fieldset class="mar-t-sm" style="margin-top: 12px !important;">
-                <label class="slab-text">
-                  <span style="display: block; margin-bottom: var(--space-1);">
-                    <span style="display: flex; align-items: center;">
-                      Document ID 
-                      <help-button>
-                        <p>Fill out "Document ID" text field and then click the "Fetch Document" button to pre-populate the Document panel.</p>
-                        <p>The Document panel is an editable text field so you can edit the fetched document or replace it with any JSON data you want.</p>
-                        <p>When you click the "Run" button the contents of the Document panel will be evaluated against your filter/projection and sent to your function as the event part of the payload.</p>
-                      </help-button>
-                    </span>
-                  </span>
-                  <div style="display: flex; flex-direction: row; gap: var(--space-2);">
-                    <input name="docid" id="docid" style="background: transparent; border-color: light-dark(var(--gray-200), var(--gray-700)); height: 2.5rem; color: light-dark(var(--gray-950), var(--gray-300));">
-                    <fetch-button></fetch-button>
-                  </div>
-                </label>
-            </fieldset>
 
+            <api-version></api-version>
+            <with-token></with-token>
+            <document-id></document-id>
           </form>
         `
   }
+
+  connectedCallback() {
+    this.innerHTML = this.renderFilters()
+    this.api.subscribe(this.renderFilters, ['selectedFunctionType'])
+  }
+
+  disconnectedCallback() {
+    this.api.unsubscribe(this.renderFilters)
+  }
 }
 
 customElements.define('filters-component', FiltersComponent)

package/dist/server/static/components/function-list.js

@@ -7,19 +7,29 @@ const template = `<ol class="hidden-lg" type="content" style="padding:0 16px;"><
 
 class FunctionList extends ApiBaseElement {
   functionClicked = (event) => {
-    // eslint-disable-next-line unicorn/prefer-dom-node-text-content
-    const target = this.api.store.functions.find((func) => func.name === event.srcElement.innerText)
+    const name = event.srcElement.closest('li').dataset.name
+    const target = this.api.store.functions.find((func) => func.name === name)
     this.api.store.selectedIndex = target.name
+    this.api.store.selectedFunctionType = target.type
   }
   functionSelected = (event) => {
     this.api.store.selectedIndex = event.srcElement.value
   }
+  renderListItem = (func) => {
+    const selected = this.api.store.selectedIndex === func.name ? 'selected' : ''
+    return `<li data-name="${func.name}" class="function-list-item ${selected} flex flex-column" style="padding: 16px 24px;">
+<span class="function-list-item-label">${func.name}</span>
+<span class="function-list-item-type capitalize">${this.renderType(func.type)}</span>
+</li>`
+  }
+  renderType = (type) => {
+    return type.split('.').pop().replaceAll('-', ' ')
+  }
   renderFunctions = () => {
     if (this.api.store.functions.length > 0) {
       this.list.innerHTML = this.api.store.functions
         .map((func) => {
-          const selected = this.api.store.selectedIndex === func.name ? 'selected' : ''
-          return `<li class="function-list-item ${selected}" style="padding: 16px 24px;">${func.name}</li>`
+          return this.renderListItem(func)
         })
         .join('')
       this.select.innerHTML = this.api.store.functions
@@ -29,7 +39,7 @@ class FunctionList extends ApiBaseElement {
         })
         .join('')
     } else {
-      this.list.innerHTML = '<option class="pad-sm">No blueprint.json file found</li>'
+      this.list.innerHTML = '<option class="pad-sm">No Blueprint found</li>'
       this.select.innerHTML = '<option>No blueprint.json file found</option>'
     }
   }

package/dist/server/static/components/run-panel.js

@@ -15,6 +15,8 @@ const template = `<div style="padding: var(--space-3);">
 class RunPanel extends ApiBaseElement {
   invoke = () => {
     const selectedEvent = this.api.store.selectedEvent
+    const docFunction = this.api.store.selectedFunctionType === 'sanity.function.document'
+
     this.api.store.result = {logs: '', time: 0}
     let event = {}
     let before = null
@@ -39,11 +41,19 @@ class RunPanel extends ApiBaseElement {
     }
     const context = {
       clientOptions: {
-        apiVersion: this.apiVersion.value,
+        apiVersion: document.querySelector('#apiversion').value,
         dataset: this.api.store.selectedDataset,
         projectId: this.api.store.selectedProject,
         token: this.api.store.withToken,
       },
+      eventResourceType: docFunction ? 'dataset' : 'media-library',
+      eventResourceId: docFunction
+        ? `${this.api.store.selectedProject}.${this.api.store.selectedDataset}`
+        : this.api.store.selectedMediaLibrary,
+      functionResourceType: 'project',
+      functionResourceId: docFunction
+        ? this.api.store.selectedProject
+        : this.api.store.selectedOrganization,
     }
     const metadata = {
       event: selectedEvent,
@@ -78,7 +88,6 @@ class RunPanel extends ApiBaseElement {
 
   connectedCallback() {
     this.innerHTML = template
-    this.apiVersion = document.querySelector('#apiversion')
     this.datasetname = document.querySelector('#datasetname')
     this.productId = document.querySelector('#project')
     this.button = this.querySelector('button')

package/dist/server/static/index.html

@@ -47,6 +47,9 @@
         <footer><run-panel></run-panel></footer>
 
 
+        <script src="./components/filter-api-version.js" type="module"></script>
+        <script src="./components/filter-document-id.js" type="module"></script>
+        <script src="./components/filter-with-token.js" type="module"></script>
         <script src="./components/filters.js" type="module"></script>
         <script src="./components/select-dropdown.js" type="module"></script>
         <script src="./components/function-list.js" type="module"></script>

package/dist/utils/display/blueprints-formatting.d.ts

@@ -1,5 +1,5 @@
 import type { Blueprint } from '@sanity/blueprints-parser';
-import type { Resource, Stack } from '../types.js';
+import { type Resource, type Stack } from '../types.js';
 export declare function formatTitle(title: string, name: string): string;
 export declare function formatResourceTree(resources: Resource[] | undefined): string;
 export declare function formatStackInfo(stack: Stack | Blueprint, isCurrentStack?: boolean): string;

package/dist/utils/display/blueprints-formatting.js

@@ -1,5 +1,6 @@
 import { treeify } from 'array-treeify';
 import chalk from 'chalk';
+import { isLocalFunctionResource } from '../types.js';
 import { formatDate, formatDuration } from './dates.js';
 import { niceId } from './presenters.js';
 import { arraifyCors, arrayifyFunction } from './resources-formatting.js';
@@ -13,7 +14,7 @@ export function formatResourceTree(resources) {
     const RESOURCE_CATEGORIES = [
         {
             label: 'Functions',
-            match: (type) => type?.startsWith('sanity.function.'),
+            match: isLocalFunctionResource,
             name: (res) => {
                 const name = chalk.bold.green(res.displayName || res.name || 'unnamed');
                 const ids = [
@@ -26,7 +27,7 @@ export function formatResourceTree(resources) {
         },
         {
             label: 'CORS Origins',
-            match: (type) => type === 'sanity.project.cors',
+            match: (r) => r.type === 'sanity.project.cors',
             name: (res) => {
                 const name = chalk.bold.yellow(res.displayName || res.name || 'unnamed');
                 const ids = [
@@ -42,7 +43,7 @@ export function formatResourceTree(resources) {
     const matchedIndices = new Set();
     for (const [i, resource] of resources.entries()) {
         for (const cat of RESOURCE_CATEGORIES) {
-            if (cat.match(resource.type)) {
+            if (cat.match(resource)) {
                 if (!categorized[cat.label])
                     categorized[cat.label] = [];
                 categorized[cat.label].push(resource);

package/dist/utils/display/resources-formatting.d.ts

@@ -1,4 +1,4 @@
 import type { TreeInput } from 'array-treeify';
-import type { CorsResource, FunctionResource } from '../../utils/types.js';
-export declare function arrayifyFunction(fn: FunctionResource): TreeInput;
+import type { CorsResource, FunctionResourceBase } from '../../utils/types.js';
+export declare function arrayifyFunction(fn: FunctionResourceBase): TreeInput;
 export declare function arraifyCors(resource: CorsResource): TreeInput;

package/dist/utils/functions/fetch-document.d.ts

@@ -1,2 +1,4 @@
 import { type ClientConfig } from '@sanity/client';
+import type { FetchConfig } from '../types.js';
 export declare function fetchDocument(documentId: string, { projectId, dataset, useCdn, apiVersion, apiHost, token }: ClientConfig): Promise<Record<string, unknown>>;
+export declare function fetchAsset(documentId: string, { mediaLibraryId, apiVersion, apiHost, token }: FetchConfig): Promise<Record<string, unknown>>;

package/dist/utils/functions/fetch-document.js

@@ -10,3 +10,18 @@ export async function fetchDocument(documentId, { projectId, dataset, useCdn = t
     }
     return data[0];
 }
+export async function fetchAsset(documentId, { mediaLibraryId, apiVersion = '2025-03-24', apiHost, token }) {
+    const spinner = ora(`Fetching document ID ${documentId}...`).start();
+    const url = `${apiHost}/v${apiVersion}/media-libraries/${mediaLibraryId}/doc/${documentId}`;
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    const data = await response.json();
+    spinner.stop();
+    if (!data?.documents[0]) {
+        throw Error(`Could not fetch document ID ${documentId}`);
+    }
+    return data.documents[0];
+}

package/dist/utils/invoke-local.d.ts

@@ -1,10 +1,10 @@
-import type { FunctionResource, GroqRule, InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadOptions } from './types.js';
+import type { FunctionResource, GroqRuleBase, InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadOptions } from './types.js';
 export declare function sanitizeLogs(logs: string): string;
 export declare const DEFAULT_GROQ_RULE: {
     on: string[];
     filter: string;
     projection: string;
 };
-export declare function isDefaultGROQRule(rule: GroqRule | undefined): boolean;
+export declare function isDefaultGROQRule(rule: GroqRuleBase | undefined): boolean;
 export declare function applyGroqRule(resource: FunctionResource, data: Record<string, unknown> | null, before: Record<string, unknown> | null, after: Record<string, unknown> | null, projectId: string | undefined, dataset: string | undefined): Promise<any>;
 export default function invoke(resource: FunctionResource, payload: InvokePayloadOptions, context: InvokeContextOptions, options: InvokeExecutionOptions): Promise<InvocationResponse>;

package/dist/utils/invoke-local.js

@@ -45,11 +45,17 @@ export async function applyGroqRule(resource, data, before, after, projectId, da
         const hasProjection = event.projection?.length;
         const projection = hasProjection ? `${event?.projection}` : '';
         const query = `*[${event?.filter}]${projection}`;
-        const rule = groq.parse(query, { mode: 'delta' });
-        const sanity = projectId && dataset ? { projectId, dataset } : undefined;
-        const queryResults = await groq.evaluate(rule, { dataset: [data], before, after, sanity });
-        const currentFunctionDocumentSet = await queryResults.get();
-        return currentFunctionDocumentSet[0];
+        try {
+            const rule = groq.parse(query, { mode: 'delta' });
+            const sanity = projectId && dataset ? { projectId, dataset } : undefined;
+            const queryResults = await groq.evaluate(rule, { dataset: [data], before, after, sanity });
+            const currentFunctionDocumentSet = await queryResults.get();
+            return currentFunctionDocumentSet[0];
+        }
+        catch (groqErr) {
+            const detail = groqErr instanceof Error && `; ${groqErr.message}`;
+            throw new Error(`Invalid rule configuration: ${query}${detail}`, { cause: groqErr });
+        }
     }
     // default groq rule so just return the data
     return data;

package/dist/utils/types.d.ts

@@ -15,17 +15,26 @@ export interface AuthParams {
     scopeId: string;
 }
 /** @internal */
-export interface GroqRule {
+export type GroqRule = GroqRuleDocumentFunction | GroqRuleMediaLibraryFunction;
+export interface GroqRuleBase {
     on: Array<string>;
     filter?: string;
+    projection?: string;
+}
+interface GroqRuleDocumentFunction extends GroqRuleBase {
     includeDrafts?: boolean;
     includeAllVersions?: boolean;
-    projection?: string;
     resource?: {
         type: 'dataset';
         id: string;
     };
 }
+interface GroqRuleMediaLibraryFunction extends GroqRuleBase {
+    resource: {
+        type: 'media-library';
+        id: string;
+    };
+}
 /** @internal */
 export interface Resource {
     name: string;
@@ -38,16 +47,27 @@ export interface DeployedResource extends Resource {
     id: string;
     externalId: string;
 }
-export declare function isLocalFunctionResource(r: Resource): r is FunctionResource;
+export declare function isLocalFunctionResource<T extends Resource>(r: T): r is T & FunctionResourceBase;
+export declare function isDocumentFunctionResource<T extends Resource>(r: T): r is T & FunctionResourceDocument;
+export declare function isMediaLibraryAssetFunctionResource<T extends Resource>(r: T): r is T & FunctionResourceMediaLibraryAsset;
 /** @internal */
-export interface FunctionResource extends Resource {
+export type FunctionResource = FunctionResourceDocument | FunctionResourceMediaLibraryAsset | FunctionResourceBase;
+export interface FunctionResourceBase extends Resource {
     src?: string;
     autoResolveDeps?: boolean;
     transpile?: boolean;
     memory?: number;
     timeout?: number;
     env?: Record<string, string>;
-    event?: GroqRule;
+    event?: GroqRuleBase;
+}
+interface FunctionResourceDocument extends FunctionResourceBase {
+    type: 'sanity.function.document';
+    event?: GroqRuleDocumentFunction;
+}
+interface FunctionResourceMediaLibraryAsset extends FunctionResourceBase {
+    type: 'sanity.function.media-library.asset';
+    event: GroqRuleMediaLibraryFunction;
 }
 export interface CorsResource extends Resource {
     origin?: string;
@@ -102,6 +122,14 @@ export interface InvokeContextOptions {
         organizationId?: string;
         token?: string;
     };
+    /** The resource type of the event source; resource type that invoked the function. */
+    eventResourceType: string;
+    /** The resource ID of the event source; resource ID that invoked the function. */
+    eventResourceId: string;
+    /** The resource type of the function container; resource type that houses the function. */
+    functionResourceType: string;
+    /** The resource ID of the function container; resource ID that houses the function. */
+    functionResourceId: string;
 }
 /** @internal */
 export interface InvokeExecutionOptions {
@@ -152,3 +180,11 @@ export interface BlueprintParserError {
     message: string;
     type: string;
 }
+/** @internal */
+export declare interface FetchConfig {
+    mediaLibraryId?: string;
+    token?: string;
+    apiHost?: string;
+    apiVersion?: string;
+}
+export {};

package/dist/utils/types.js

@@ -1,6 +1,14 @@
 export function isLocalFunctionResource(r) {
     return r.type.startsWith('sanity.function.');
 }
+// annoyed that checking for equality on `type` isnt sufficient to narrow down to a specific type from a union
+// instead need to use these type predicated
+export function isDocumentFunctionResource(r) {
+    return r.type === 'sanity.function.document';
+}
+export function isMediaLibraryAssetFunctionResource(r) {
+    return r.type === 'sanity.function.media-library.asset';
+}
 export function isEventType(arg) {
     return ['create', 'update', 'delete'].includes(arg);
 }