@sanity/workflow-studio 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -1,13 +1,15 @@
 import { DatasetResourceId } from "@sanity/workflow-react/observer";
 import type { DocumentStore } from "sanity";
+import { EffectHandler } from "@sanity/workflow-engine";
 import { Engine } from "@sanity/workflow-engine";
 import type { GdrUri } from "@sanity/workflow-engine";
 import type { InstancesQueryFilter } from "@sanity/workflow-engine";
+import { MissingHandlerPolicy } from "@sanity/workflow-engine";
 import { MutationGuardDoc } from "@sanity/workflow-react";
 import { ResourceClientResolver } from "@sanity/workflow-engine";
-import type { SanityInstance } from "@sanity/sdk";
+import type { SanityClient } from "sanity";
+import { SanityInstance } from "@sanity/sdk";
 import { useClient } from "sanity";
-import type { WorkflowAccessOverride } from "@sanity/workflow-engine";
 import { WorkflowInstanceList } from "@sanity/workflow-react";
 import { WorkflowObserver } from "@sanity/workflow-react/observer";
 import { WorkflowResource } from "@sanity/workflow-engine";
@@ -40,6 +42,9 @@ export declare interface StudioObserverOptions {
   /** The workspace's project + dataset — the only resource Studio's
    *  `documentStore` can address. */
   mounted: DatasetResourceId;
+  /** A workspace-bound client — carries `ensureDocumentExists` writes, which
+   *  address the mounted dataset (where the workspace's subject docs live). */
+  client: SanityClient;
   /** The engine's state dataset (`datasetResourceId(engine.workflowResource)`)
    *  — where the instance doc and its verdict-relevant guards live. Routinely
    *  a dedicated `workflows` dataset distinct from the workspace. */
@@ -54,9 +59,11 @@ export declare interface StudioObserverOptions {
 /**
  * The default Studio {@link ResourceClientResolver}: any fully-addressed
  * `dataset:` GDR resolves to the workspace client rebound to that
- * project/dataset; other schemes (media-library, canvas) return `undefined` so
- * the engine falls back to its own client. A custom resolver can delegate to
- * this for the dataset arm and handle other schemes itself.
+ * project/dataset; other schemes (media-library, canvas) return `undefined`,
+ * letting the engine route them — a sibling client derived from the engine
+ * client's own credentials for foreign resources, its own client for the
+ * workflow resource. A custom resolver can delegate to this for the dataset
+ * arm and handle other schemes itself.
  */
 export declare function studioResourceClients(
   client: StudioClient,
@@ -75,26 +82,46 @@ export declare function useDocumentWorkflows({
   sdk?: SanityInstance;
 }): WorkflowInstanceList;
 
+/**
+ * The Studio observer for this engine — the shared wiring under every
+ * reactive hook in this package. Workspace-dataset streams ride
+ * `documentStore`; anything foreign (routinely the engine's dedicated
+ * `workflows` dataset) rides an App SDK instance, bootstrapped from the
+ * Studio session when the caller doesn't supply one. Must run inside Studio
+ * source context (so `useDocumentStore`/`useSource` resolve).
+ */
+export declare function useStudioObserver({
+  engine,
+  sdk: suppliedSdk,
+}: {
+  engine: Engine;
+  sdk?: SanityInstance | undefined;
+}): WorkflowObserver;
+
 /**
  * Build the Studio-side engine once: the workspace client rebound to the
  * engine's state dataset, plus {@link studioResourceClients} as the default
  * per-resource routing — so subjects and refs across many content datasets
  * resolve without call sites assembling clients. Pass `resourceClients` to
  * override the routing (compose with {@link studioResourceClients} to keep
- * dataset-GDR routing). Memoized on the config's content, so inline
- * `workflowResource` literals are fine; a custom `resourceClients` function
- * should still be stable. Must render inside Studio source context.
+ * dataset-GDR routing). `effectHandlers`/`missingHandler` feed
+ * {@link Engine.drainEffects} for engines that drain effects in the Studio.
+ * Memoized on the config's content, so inline `workflowResource` literals are
+ * fine; custom `resourceClients` and `effectHandlers` values should still be
+ * stable. Must render inside Studio source context.
  */
 export declare function useWorkflowEngine({
   workflowResource,
   tag,
   resourceClients,
-  apiVersion,
+  effectHandlers,
+  missingHandler,
 }: {
   workflowResource: WorkflowResource;
   tag: string;
   resourceClients?: ResourceClientResolver;
-  apiVersion?: string;
+  effectHandlers?: Record<string, EffectHandler>;
+  missingHandler?: MissingHandlerPolicy;
 }): Engine;
 
 /** A live, filterable workflow-instance list observed from Sanity Studio —
@@ -120,19 +147,18 @@ export declare function useWorkflowInstances({
  * from the workspace, an SDK instance is bootstrapped automatically from the
  * Studio session (pass `sdk` to supply your own — required for
  * cookie-authenticated studios, where no session token is readable). Returns
- * `{evaluation, ready, guards, tick, fireAction, editField}`; the consumer decides when
- * to advance. Must render inside Studio source context.
+ * the full {@link WorkflowSession} (evaluation, ready, guards, and the
+ * tick/fireAction/editField/preview verbs); the consumer decides when to
+ * advance. Must render inside Studio source context.
  */
 export declare function useWorkflowSession({
   engine,
   instanceId,
-  access,
   grantsFromPath,
   sdk,
 }: {
   engine: Engine;
   instanceId: string;
-  access?: WorkflowAccessOverride;
   grantsFromPath?: string;
   sdk?: SanityInstance;
 }): WorkflowSession;

package/dist/index.js

@@ -1,218 +1,254 @@
-import { instanceGuardQuery, contentReleaseName, WORKFLOW_INSTANCE_TYPE, ENGINE_API_VERSION, createEngine } from "@sanity/workflow-engine";
-import { sameDataset, combineGuardStores, combineDocStores, classifyRef, useKeyed, datasetResourceId } from "@sanity/workflow-react/observer";
+import { instanceGuardQuery, contentReleaseName, WORKFLOW_INSTANCE_TYPE, ENGINE_API_VERSION, createEngine, EXECUTION_KINDS } from "@sanity/workflow-engine";
+
+import { sameDataset, ensureDocumentExists, combineGuardStores, combineDocStores, classifyRef, datasetResourceId, useKeyed } from "@sanity/workflow-react/observer";
+
 import { sdkInstancesStore, sdkGuardStore, sdkContentDocStore, sdkInstanceDocStore } from "@sanity/workflow-sdk/observer";
-import { useMemo, useRef, useEffect } from "react";
-import { useClient, useDocumentStore, useSource } from "sanity";
-import { useWorkflowSession as useWorkflowSession$1, useDocumentWorkflows as useDocumentWorkflows$1, useWorkflowInstances as useWorkflowInstances$1 } from "@sanity/workflow-react";
+
 import { createSanityInstance } from "@sanity/sdk";
-function observableStore({
-  observable,
-  resolve,
-  initial
-}) {
-  let latest = initial;
-  return {
-    subscribe(onChange) {
-      const subscription = observable.subscribe((value) => {
-        latest = resolve(value), onChange();
-      });
-      return () => subscription.unsubscribe();
-    },
-    getSnapshot: () => latest
-  };
+
+import { useMemo, useRef, useEffect } from "react";
+
+import { useDocumentStore, useSource, useClient } from "sanity";
+
+import { useWorkflowTelemetry, useWorkflowSession as useWorkflowSession$1, useDocumentWorkflows as useDocumentWorkflows$1, useWorkflowInstances as useWorkflowInstances$1 } from "@sanity/workflow-react";
+
+const RESUBSCRIBE_DELAY_MS = 5e3;
+
+function observableStore({observable: observable, resolve: resolve, initial: initial, name: name}) {
+    let latest = initial;
+    return {
+        subscribe(onChange) {
+            let subscription, retry, stopped = !1;
+            const connect = () => {
+                subscription = observable.subscribe({
+                    next: value => {
+                        latest = resolve(value), onChange();
+                    },
+                    error: err => {
+                        console.error(`[workflow-studio] ${name} stream errored — resubscribing in ${RESUBSCRIBE_DELAY_MS / 1e3}s:`, err), 
+                        stopped || (retry = setTimeout(connect, RESUBSCRIBE_DELAY_MS));
+                    }
+                });
+            };
+            return connect(), () => {
+                stopped = !0, retry !== void 0 && clearTimeout(retry), subscription?.unsubscribe();
+            };
+        },
+        getSnapshot: () => latest
+    };
 }
+
 function makeStudioObserver(documentStore, options) {
-  const { mounted, engineResource, sdk } = options, engineIsMounted = sameDataset(engineResource, mounted), editStateStore = ({
-    id,
-    type,
-    release
-  }) => observableStore({
-    observable: documentStore.pair.editState(id, type, release),
-    resolve: resolveEditState,
-    initial: void 0
-  }), requireSdk = (what) => {
-    if (sdk !== void 0) return sdk;
-    throw new Error(
-      `@sanity/workflow-studio: ${what} \u2014 Studio's document store is bound to ${mounted.projectId}.${mounted.dataset} and cannot observe it. Pass an App SDK instance via the hook's \`sdk\` option (e.g. \`useWorkflowSession({engine, instanceId, sdk})\`) to observe foreign resources.`
-    );
-  };
-  return {
-    observeInstance: (instanceId) => engineIsMounted ? editStateStore({ id: instanceId, type: WORKFLOW_INSTANCE_TYPE, release: void 0 }) : sdkInstanceDocStore({
-      sdk: requireSdk(
-        `instance "${instanceId}" lives in the engine dataset ${engineResource.projectId}.${engineResource.dataset}`
-      ),
-      instanceId,
-      engineResource
-    }),
-    observeDocs: (documents, perspective) => combineDocStores(
-      documents.map((ref) => classifyRef(ref, mounted) === "mounted-dataset" ? {
-        key: ref.globalDocumentId,
-        store: editStateStore({
-          id: ref.documentId,
-          type: ref.type,
-          release: contentReleaseName({ ref, perspective })
-        })
-      } : {
-        key: ref.globalDocumentId,
-        store: sdkContentDocStore({
-          sdk: requireSdk(`"${ref.globalDocumentId}" lives outside this workspace`),
-          ref,
-          perspective
-        })
-      })
-    ),
-    observeGuards: (instanceId, resources) => combineGuardStores(
-      resources.map((resource) => {
-        if (sameDataset(resource, mounted)) {
-          const { query, params } = instanceGuardQuery(instanceId);
-          return observableStore({
-            observable: documentStore.listenQuery(query, params, {}),
-            resolve: (docs) => docs,
-            initial: void 0
-          });
-        }
-        return sdkGuardStore({
-          sdk: requireSdk(
-            `guards for "${instanceId}" live in ${resource.projectId}.${resource.dataset}`
-          ),
-          instanceId,
-          resource
-        });
-      })
-    ),
-    observeInstances: (query) => engineIsMounted ? observableStore({
-      observable: documentStore.listenQuery(query.query, query.params, {}),
-      resolve: (docs) => docs,
-      initial: void 0
-    }) : sdkInstancesStore({
-      sdk: requireSdk(
-        `the instance list lives in the engine dataset ${engineResource.projectId}.${engineResource.dataset}`
-      ),
-      query,
-      resource: engineResource
-    })
-  };
+    const {mounted: mounted, engineResource: engineResource, sdk: sdk, client: client} = options, engineIsMounted = sameDataset(engineResource, mounted), editStateStore = ({id: id, type: type, release: release}) => observableStore({
+        observable: documentStore.pair.editState(id, type, release),
+        resolve: resolveEditState,
+        initial: void 0,
+        name: `the edit state of "${id}"`
+    }), requireSdk = what => {
+        if (sdk !== void 0) return sdk;
+        throw new Error(`@sanity/workflow-studio: ${what} — Studio's document store is bound to ${mounted.projectId}.${mounted.dataset} and cannot observe it. Pass an App SDK instance via the hook's \`sdk\` option (e.g. \`useWorkflowSession({engine, instanceId, sdk})\`) to observe foreign resources.`);
+    };
+    return {
+        observeInstance: instanceId => engineIsMounted ? editStateStore({
+            id: instanceId,
+            type: WORKFLOW_INSTANCE_TYPE,
+            release: void 0
+        }) : sdkInstanceDocStore({
+            sdk: requireSdk(`instance "${instanceId}" lives in the engine dataset ${engineResource.projectId}.${engineResource.dataset}`),
+            instanceId: instanceId,
+            engineResource: engineResource
+        }),
+        observeDocs: (documents, perspective) => combineDocStores(documents.map(ref => classifyRef(ref, mounted) === "mounted-dataset" ? {
+            key: ref.globalDocumentId,
+            store: editStateStore({
+                id: ref.documentId,
+                type: ref.type,
+                release: contentReleaseName({
+                    ref: ref,
+                    perspective: perspective
+                })
+            })
+        } : {
+            key: ref.globalDocumentId,
+            store: sdkContentDocStore({
+                sdk: requireSdk(`"${ref.globalDocumentId}" lives outside this workspace`),
+                ref: ref,
+                perspective: perspective
+            })
+        })),
+        observeGuards: (instanceId, resources) => combineGuardStores(resources.map(resource => {
+            if (sameDataset(resource, mounted)) {
+                const {query: query, params: params} = instanceGuardQuery(instanceId);
+                return observableStore({
+                    observable: documentStore.listenQuery(query, params, {}),
+                    resolve: docs => docs,
+                    initial: void 0,
+                    name: `the guard list for "${instanceId}"`
+                });
+            }
+            return sdkGuardStore({
+                sdk: requireSdk(`guards for "${instanceId}" live in ${resource.projectId}.${resource.dataset}`),
+                instanceId: instanceId,
+                resource: resource
+            });
+        })),
+        observeInstances: query => engineIsMounted ? observableStore({
+            observable: documentStore.listenQuery(query.query, query.params, {}),
+            resolve: docs => docs,
+            initial: void 0,
+            name: "the instance list"
+        }) : sdkInstancesStore({
+            sdk: requireSdk(`the instance list lives in the engine dataset ${engineResource.projectId}.${engineResource.dataset}`),
+            query: query,
+            resource: engineResource
+        }),
+        ensureDocumentExists: args => ensureDocumentExists(client, args)
+    };
 }
+
 function resolveEditState(editState) {
-  if (editState.ready)
-    return editState.version ?? editState.draft ?? editState.published;
+    if (editState.ready) return editState.version ?? editState.draft ?? editState.published;
 }
-function useWorkflowEngine({
-  workflowResource,
-  tag,
-  resourceClients,
-  apiVersion
-}) {
-  const client = useClient({ apiVersion: apiVersion ?? ENGINE_API_VERSION }), resource = useKeyed([workflowResource.type, workflowResource.id], () => workflowResource);
-  return useMemo(() => {
-    const engineDataset = datasetResourceId(resource), engineClient = client.withConfig({
-      projectId: engineDataset.projectId,
-      dataset: engineDataset.dataset,
-      useCdn: !1
-    });
-    return createEngine({
-      client: engineClient,
-      workflowResource: resource,
-      tag,
-      resourceClients: resourceClients ?? studioResourceClients(client)
+
+const SESSION_CLIENT_OPTIONS = {
+    apiVersion: ENGINE_API_VERSION
+};
+
+function useStudioObserver({engine: engine, sdk: suppliedSdk}) {
+    const documentStore = useDocumentStore(), source = useSource(), {projectId: projectId, dataset: dataset} = source, mounted = useMemo(() => ({
+        projectId: projectId,
+        dataset: dataset
+    }), [ projectId, dataset ]), engineResource = useMemo(() => datasetResourceId(engine.workflowResource), [ engine ]), sdk = useEmbeddedSdk({
+        supplied: suppliedSdk,
+        needed: !sameDataset(engineResource, mounted),
+        mounted: mounted,
+        sessionToken: source.getClient(SESSION_CLIENT_OPTIONS).config().token
     });
-  }, [client, resource, tag, resourceClients]);
+    return useMemo(() => makeStudioObserver(documentStore, {
+        mounted: mounted,
+        client: source.getClient(SESSION_CLIENT_OPTIONS),
+        engineResource: engineResource,
+        ...sdk !== void 0 ? {
+            sdk: sdk
+        } : {}
+    }), [ documentStore, source, mounted, engineResource, sdk ]);
 }
-function studioResourceClients(client) {
-  return (parsed) => parsed.scheme === "dataset" && parsed.projectId !== void 0 && parsed.dataset !== void 0 ? client.withConfig({ projectId: parsed.projectId, dataset: parsed.dataset, useCdn: !1 }) : void 0;
-}
-const SESSION_CLIENT_OPTIONS = { apiVersion: ENGINE_API_VERSION };
-function useStudioObserver({
-  engine,
-  sdk: suppliedSdk
-}) {
-  const documentStore = useDocumentStore(), source = useSource(), { projectId, dataset } = source, mounted = useMemo(() => ({ projectId, dataset }), [projectId, dataset]), engineResource = useMemo(() => datasetResourceId(engine.workflowResource), [engine]), sdk = useEmbeddedSdk({
-    supplied: suppliedSdk,
-    // The engine dataset being foreign is the signal an SDK instance is
-    // needed; foreign content refs without one still fail loud per ref.
-    needed: !sameDataset(engineResource, mounted),
-    mounted,
-    // The session's token rides the source client's config (absent under
-    // cookie auth) — the public read; Studio's token storage is private.
-    sessionToken: source.getClient(SESSION_CLIENT_OPTIONS).config().token
-  });
-  return useMemo(
-    () => makeStudioObserver(documentStore, {
-      mounted,
-      engineResource,
-      ...sdk !== void 0 ? { sdk } : {}
-    }),
-    [documentStore, mounted, engineResource, sdk]
-  );
-}
-function useEmbeddedSdk({
-  supplied,
-  needed,
-  mounted,
-  sessionToken
-}) {
-  const wanted = supplied === void 0 && needed, held = useRef(void 0), key = `${mounted.projectId}.${mounted.dataset}`;
-  wanted && (held.current?.key !== key || held.current.instance.isDisposed()) && (held.current = { key, instance: bootstrapInstance(mounted, sessionToken) });
-  const embedded = wanted ? held.current?.instance : void 0;
-  return useDeferredDispose(embedded), supplied ?? embedded;
+
+function useEmbeddedSdk({supplied: supplied, needed: needed, mounted: mounted, sessionToken: sessionToken}) {
+    const wanted = supplied === void 0 && needed, held = useRef(void 0), key = `${mounted.projectId}.${mounted.dataset}`;
+    wanted && (held.current?.key !== key || held.current.instance.isDisposed()) && (held.current = {
+        key: key,
+        instance: bootstrapInstance(mounted, sessionToken)
+    });
+    const embedded = wanted ? held.current?.instance : void 0;
+    return useDeferredDispose(embedded), supplied ?? embedded;
 }
+
 function bootstrapInstance(mounted, sessionToken) {
-  if (sessionToken === void 0)
-    throw new Error(
-      "@sanity/workflow-studio: the engine's state dataset is not this workspace's dataset, and no Studio session token is readable to bootstrap an App SDK instance (cookie-authenticated studio?). Pass one explicitly via the hook's `sdk` option, e.g. useWorkflowSession({engine, instanceId, sdk})."
-    );
-  return createSanityInstance({
-    projectId: mounted.projectId,
-    dataset: mounted.dataset,
-    auth: { token: sessionToken }
-  });
+    if (sessionToken === void 0) throw new Error("@sanity/workflow-studio: the engine's state dataset is not this workspace's dataset, and no Studio session token is readable to bootstrap an App SDK instance (cookie-authenticated studio?). Pass one explicitly via the hook's `sdk` option, e.g. useWorkflowSession({engine, instanceId, sdk}).");
+    return createSanityInstance({
+        projectId: mounted.projectId,
+        dataset: mounted.dataset,
+        auth: {
+            token: sessionToken
+        }
+    });
 }
+
 function useDeferredDispose(instance) {
-  const disposal = useRef(void 0);
-  useEffect(() => {
-    if (instance !== void 0)
-      return disposal.current?.instance === instance && (clearTimeout(disposal.current.timeoutId), disposal.current = void 0), () => {
-        disposal.current = {
-          instance,
-          timeoutId: setTimeout(() => {
-            instance.isDisposed() || instance.dispose();
-          }, 0)
+    const disposal = useRef(void 0);
+    useEffect(() => {
+        if (instance !== void 0) return disposal.current?.instance === instance && (clearTimeout(disposal.current.timeoutId), 
+        disposal.current = void 0), () => {
+            disposal.current = {
+                instance: instance,
+                timeoutId: setTimeout(() => {
+                    instance.isDisposed() || instance.dispose();
+                }, 0)
+            };
         };
-      };
-  }, [instance]);
+    }, [ instance ]);
 }
-function useWorkflowSession({
-  engine,
-  instanceId,
-  access,
-  grantsFromPath,
-  sdk
-}) {
-  const observer = useStudioObserver({ engine, sdk });
-  return useWorkflowSession$1({ engine, instanceId, observer, opts: { access, grantsFromPath } });
+
+function useWorkflowEngine({workflowResource: workflowResource, tag: tag, resourceClients: resourceClients, effectHandlers: effectHandlers, missingHandler: missingHandler}) {
+    const client = useClient({
+        apiVersion: ENGINE_API_VERSION
+    }), resource = useKeyed([ workflowResource.type, workflowResource.id ], () => workflowResource), telemetry = useWorkflowTelemetry();
+    return useMemo(() => {
+        const engineDataset = datasetResourceId(resource), engineClient = client.withConfig({
+            projectId: engineDataset.projectId,
+            dataset: engineDataset.dataset,
+            useCdn: !1,
+            requestTagPrefix: "sanity.workflows.studio"
+        });
+        return createEngine({
+            client: engineClient,
+            workflowResource: resource,
+            tag: tag,
+            resourceClients: resourceClients ?? studioResourceClients(client),
+            executionContext: {
+                kind: EXECUTION_KINDS.studio
+            },
+            ...effectHandlers !== void 0 ? {
+                effectHandlers: effectHandlers
+            } : {},
+            ...missingHandler !== void 0 ? {
+                missingHandler: missingHandler
+            } : {},
+            telemetry: telemetry
+        });
+    }, [ client, resource, tag, resourceClients, effectHandlers, missingHandler, telemetry ]);
 }
-function useWorkflowInstances({
-  engine,
-  filter,
-  sdk
-}) {
-  const observer = useStudioObserver({ engine, sdk });
-  return useWorkflowInstances$1({ engine, observer, ...filter !== void 0 ? { filter } : {} });
+
+function studioResourceClients(client) {
+    return parsed => parsed.scheme === "dataset" && parsed.projectId !== void 0 && parsed.dataset !== void 0 ? client.withConfig({
+        projectId: parsed.projectId,
+        dataset: parsed.dataset,
+        useCdn: !1,
+        requestTagPrefix: "sanity.workflows.studio"
+    }) : void 0;
 }
-function useDocumentWorkflows({
-  engine,
-  document,
-  sdk
-}) {
-  const observer = useStudioObserver({ engine, sdk });
-  return useDocumentWorkflows$1({ engine, observer, document });
+
+function useWorkflowSession({engine: engine, instanceId: instanceId, grantsFromPath: grantsFromPath, sdk: sdk}) {
+    const observer = useStudioObserver({
+        engine: engine,
+        sdk: sdk
+    });
+    return useWorkflowSession$1({
+        engine: engine,
+        instanceId: instanceId,
+        observer: observer,
+        host: "studio",
+        opts: {
+            grantsFromPath: grantsFromPath
+        }
+    });
 }
-export {
-  makeStudioObserver,
-  studioResourceClients,
-  useDocumentWorkflows,
-  useWorkflowEngine,
-  useWorkflowInstances,
-  useWorkflowSession
-};
-//# sourceMappingURL=index.js.map
+
+function useWorkflowInstances({engine: engine, filter: filter, sdk: sdk}) {
+    const observer = useStudioObserver({
+        engine: engine,
+        sdk: sdk
+    });
+    return useWorkflowInstances$1({
+        engine: engine,
+        observer: observer,
+        ...filter !== void 0 ? {
+            filter: filter
+        } : {}
+    });
+}
+
+function useDocumentWorkflows({engine: engine, document: document, sdk: sdk}) {
+    const observer = useStudioObserver({
+        engine: engine,
+        sdk: sdk
+    });
+    return useDocumentWorkflows$1({
+        engine: engine,
+        observer: observer,
+        document: document
+    });
+}
+
+export { makeStudioObserver, studioResourceClients, useDocumentWorkflows, useStudioObserver, useWorkflowEngine, useWorkflowInstances, useWorkflowSession };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/workflow-studio",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "React adapter that drives the @sanity/workflow-engine reactive session from the Sanity Studio document store.",
   "keywords": [
     "sanity",
@@ -21,7 +21,8 @@
     "directory": "packages/workflow-studio"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "sideEffects": false,
@@ -37,12 +38,12 @@
     "./package.json": "./package.json"
   },
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
   "dependencies": {
-    "@sanity/workflow-engine": "0.14.0",
-    "@sanity/workflow-react": "0.9.0",
-    "@sanity/workflow-sdk": "0.6.0"
+    "@sanity/workflow-engine": "0.15.0",
+    "@sanity/workflow-react": "0.10.0",
+    "@sanity/workflow-sdk": "0.7.0"
   },
   "devDependencies": {
     "@sanity/pkg-utils": "^10.5.2",