@sanity/workflow-engine 0.7.0 → 0.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/_chunks-cjs/schema.cjs +83 -14
- package/dist/_chunks-cjs/schema.cjs.map +1 -1
- package/dist/_chunks-es/schema.js +83 -14
- package/dist/_chunks-es/schema.js.map +1 -1
- package/dist/define.cjs +99 -20
- package/dist/define.cjs.map +1 -1
- package/dist/define.d.cts +659 -58
- package/dist/define.d.ts +659 -58
- package/dist/define.js +100 -21
- package/dist/define.js.map +1 -1
- package/dist/index.cjs +708 -255
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +1180 -97
- package/dist/index.d.ts +1180 -97
- package/dist/index.js +710 -256
- package/dist/index.js.map +1 -1
- package/package.json +1 -1
package/dist/index.d.cts
CHANGED
|
@@ -112,10 +112,15 @@ export declare interface Actor {
|
|
|
112
112
|
/**
|
|
113
113
|
* Free-form role names — typically a copy of Sanity's `user.roles[].name`
|
|
114
114
|
* for the token behind the call. The engine treats these as opaque
|
|
115
|
-
* strings
|
|
116
|
-
*
|
|
117
|
-
*
|
|
118
|
-
*
|
|
115
|
+
* strings, matched by literal membership: `Action.roles` and `assignees`
|
|
116
|
+
* roles OR-match against this list. There is no actor-side wildcard — a
|
|
117
|
+
* `"*"` here is just a literal string and matches nothing on its own.
|
|
118
|
+
*
|
|
119
|
+
* To let one role satisfy a gate it doesn't literally name — e.g. an
|
|
120
|
+
* `administrator` satisfying a narrower gate, or one deployment's role
|
|
121
|
+
* standing in for another's — declare the definition's `roleAliases`
|
|
122
|
+
* "can be fulfilled by" map; it widens the REQUIRED side, never the
|
|
123
|
+
* actor's roles.
|
|
119
124
|
*/
|
|
120
125
|
roles?: string[];
|
|
121
126
|
onBehalfOf?: string;
|
|
@@ -724,6 +729,38 @@ declare const AuthoringActionSchema: v.UnionSchema<
|
|
|
724
729
|
undefined
|
|
725
730
|
>;
|
|
726
731
|
|
|
732
|
+
export declare type AuthoringEditable = v.InferOutput<
|
|
733
|
+
typeof AuthoringEditableSchema
|
|
734
|
+
>;
|
|
735
|
+
|
|
736
|
+
/**
|
|
737
|
+
* Authoring editability adds the `role[]` convenience: a non-empty role list
|
|
738
|
+
* desugars to the same `count($actor.roles[@ in [...]]) > 0` membership
|
|
739
|
+
* predicate `action.roles` produces. `true` opens the slot to anyone in its
|
|
740
|
+
* window; a bare string is a raw predicate.
|
|
741
|
+
*/
|
|
742
|
+
declare const AuthoringEditableSchema: v.UnionSchema<
|
|
743
|
+
[
|
|
744
|
+
v.LiteralSchema<true, undefined>,
|
|
745
|
+
v.ArraySchema<
|
|
746
|
+
v.SchemaWithPipe<
|
|
747
|
+
readonly [
|
|
748
|
+
v.StringSchema<undefined>,
|
|
749
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
750
|
+
]
|
|
751
|
+
>,
|
|
752
|
+
undefined
|
|
753
|
+
>,
|
|
754
|
+
v.SchemaWithPipe<
|
|
755
|
+
readonly [
|
|
756
|
+
v.StringSchema<undefined>,
|
|
757
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
758
|
+
]
|
|
759
|
+
>,
|
|
760
|
+
],
|
|
761
|
+
undefined
|
|
762
|
+
>;
|
|
763
|
+
|
|
727
764
|
export declare type AuthoringStage = v.InferOutput<typeof AuthoringStageSchema>;
|
|
728
765
|
|
|
729
766
|
declare const AuthoringStageSchema: v.StrictObjectSchema<
|
|
@@ -1911,7 +1948,7 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
|
|
|
1911
1948
|
[
|
|
1912
1949
|
v.StrictObjectSchema<
|
|
1913
1950
|
{
|
|
1914
|
-
|
|
1951
|
+
type: v.PicklistSchema<
|
|
1915
1952
|
readonly [
|
|
1916
1953
|
"doc.ref",
|
|
1917
1954
|
"doc.refs",
|
|
@@ -1929,21 +1966,65 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
|
|
|
1929
1966
|
],
|
|
1930
1967
|
`Invalid option: expected one of ${string}`
|
|
1931
1968
|
>;
|
|
1932
|
-
|
|
1969
|
+
name: v.SchemaWithPipe<
|
|
1933
1970
|
readonly [
|
|
1934
1971
|
v.StringSchema<undefined>,
|
|
1935
1972
|
v.RegexAction<string, string>,
|
|
1936
1973
|
]
|
|
1937
1974
|
>;
|
|
1938
|
-
|
|
1975
|
+
title: v.OptionalSchema<
|
|
1939
1976
|
v.StringSchema<undefined>,
|
|
1940
1977
|
undefined
|
|
1941
1978
|
>;
|
|
1942
|
-
|
|
1979
|
+
description: v.OptionalSchema<
|
|
1943
1980
|
v.StringSchema<undefined>,
|
|
1944
1981
|
undefined
|
|
1945
1982
|
>;
|
|
1946
|
-
|
|
1983
|
+
/**
|
|
1984
|
+
* When true, the caller MUST supply this entry at start (via
|
|
1985
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
1986
|
+
* missing required entry throws rather than silently defaulting to
|
|
1987
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
1988
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
1989
|
+
*/
|
|
1990
|
+
required: v.OptionalSchema<
|
|
1991
|
+
v.BooleanSchema<undefined>,
|
|
1992
|
+
undefined
|
|
1993
|
+
>;
|
|
1994
|
+
source: v.GenericSchema<SourceInternal>;
|
|
1995
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
1996
|
+
editable: v.OptionalSchema<
|
|
1997
|
+
v.UnionSchema<
|
|
1998
|
+
[
|
|
1999
|
+
v.LiteralSchema<true, undefined>,
|
|
2000
|
+
v.ArraySchema<
|
|
2001
|
+
v.SchemaWithPipe<
|
|
2002
|
+
readonly [
|
|
2003
|
+
v.StringSchema<undefined>,
|
|
2004
|
+
v.MinLengthAction<
|
|
2005
|
+
string,
|
|
2006
|
+
1,
|
|
2007
|
+
"must be a non-empty string"
|
|
2008
|
+
>,
|
|
2009
|
+
]
|
|
2010
|
+
>,
|
|
2011
|
+
undefined
|
|
2012
|
+
>,
|
|
2013
|
+
v.SchemaWithPipe<
|
|
2014
|
+
readonly [
|
|
2015
|
+
v.StringSchema<undefined>,
|
|
2016
|
+
v.MinLengthAction<
|
|
2017
|
+
string,
|
|
2018
|
+
1,
|
|
2019
|
+
"must be a non-empty string"
|
|
2020
|
+
>,
|
|
2021
|
+
]
|
|
2022
|
+
>,
|
|
2023
|
+
],
|
|
2024
|
+
undefined
|
|
2025
|
+
>,
|
|
2026
|
+
undefined
|
|
2027
|
+
>;
|
|
1947
2028
|
},
|
|
1948
2029
|
undefined
|
|
1949
2030
|
>,
|
|
@@ -2460,7 +2541,7 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
|
|
|
2460
2541
|
[
|
|
2461
2542
|
v.StrictObjectSchema<
|
|
2462
2543
|
{
|
|
2463
|
-
|
|
2544
|
+
type: v.PicklistSchema<
|
|
2464
2545
|
readonly [
|
|
2465
2546
|
"doc.ref",
|
|
2466
2547
|
"doc.refs",
|
|
@@ -2478,21 +2559,62 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
|
|
|
2478
2559
|
],
|
|
2479
2560
|
`Invalid option: expected one of ${string}`
|
|
2480
2561
|
>;
|
|
2481
|
-
|
|
2562
|
+
name: v.SchemaWithPipe<
|
|
2482
2563
|
readonly [
|
|
2483
2564
|
v.StringSchema<undefined>,
|
|
2484
2565
|
v.RegexAction<string, string>,
|
|
2485
2566
|
]
|
|
2486
2567
|
>;
|
|
2487
|
-
|
|
2568
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
2569
|
+
description: v.OptionalSchema<
|
|
2488
2570
|
v.StringSchema<undefined>,
|
|
2489
2571
|
undefined
|
|
2490
2572
|
>;
|
|
2491
|
-
|
|
2492
|
-
|
|
2573
|
+
/**
|
|
2574
|
+
* When true, the caller MUST supply this entry at start (via
|
|
2575
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
2576
|
+
* missing required entry throws rather than silently defaulting to
|
|
2577
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
2578
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
2579
|
+
*/
|
|
2580
|
+
required: v.OptionalSchema<
|
|
2581
|
+
v.BooleanSchema<undefined>,
|
|
2582
|
+
undefined
|
|
2583
|
+
>;
|
|
2584
|
+
source: v.GenericSchema<SourceInternal>;
|
|
2585
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
2586
|
+
editable: v.OptionalSchema<
|
|
2587
|
+
v.UnionSchema<
|
|
2588
|
+
[
|
|
2589
|
+
v.LiteralSchema<true, undefined>,
|
|
2590
|
+
v.ArraySchema<
|
|
2591
|
+
v.SchemaWithPipe<
|
|
2592
|
+
readonly [
|
|
2593
|
+
v.StringSchema<undefined>,
|
|
2594
|
+
v.MinLengthAction<
|
|
2595
|
+
string,
|
|
2596
|
+
1,
|
|
2597
|
+
"must be a non-empty string"
|
|
2598
|
+
>,
|
|
2599
|
+
]
|
|
2600
|
+
>,
|
|
2601
|
+
undefined
|
|
2602
|
+
>,
|
|
2603
|
+
v.SchemaWithPipe<
|
|
2604
|
+
readonly [
|
|
2605
|
+
v.StringSchema<undefined>,
|
|
2606
|
+
v.MinLengthAction<
|
|
2607
|
+
string,
|
|
2608
|
+
1,
|
|
2609
|
+
"must be a non-empty string"
|
|
2610
|
+
>,
|
|
2611
|
+
]
|
|
2612
|
+
>,
|
|
2613
|
+
],
|
|
2614
|
+
undefined
|
|
2615
|
+
>,
|
|
2493
2616
|
undefined
|
|
2494
2617
|
>;
|
|
2495
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
2496
2618
|
},
|
|
2497
2619
|
undefined
|
|
2498
2620
|
>,
|
|
@@ -2523,6 +2645,43 @@ declare const AuthoringStageSchema: v.StrictObjectSchema<
|
|
|
2523
2645
|
>,
|
|
2524
2646
|
undefined
|
|
2525
2647
|
>;
|
|
2648
|
+
/**
|
|
2649
|
+
* Tighten-only editability overrides for the time this stage holds, keyed
|
|
2650
|
+
* by an in-scope slot name. The slot's own `editable` is the ceiling; a
|
|
2651
|
+
* stage value is ANDed with it at runtime, so an override can only NARROW
|
|
2652
|
+
* (never open a slot the baseline left closed). An unlisted slot inherits
|
|
2653
|
+
* its baseline.
|
|
2654
|
+
*/
|
|
2655
|
+
editable: v.OptionalSchema<
|
|
2656
|
+
v.RecordSchema<
|
|
2657
|
+
v.SchemaWithPipe<
|
|
2658
|
+
readonly [v.StringSchema<undefined>, v.RegexAction<string, string>]
|
|
2659
|
+
>,
|
|
2660
|
+
v.UnionSchema<
|
|
2661
|
+
[
|
|
2662
|
+
v.LiteralSchema<true, undefined>,
|
|
2663
|
+
v.ArraySchema<
|
|
2664
|
+
v.SchemaWithPipe<
|
|
2665
|
+
readonly [
|
|
2666
|
+
v.StringSchema<undefined>,
|
|
2667
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
2668
|
+
]
|
|
2669
|
+
>,
|
|
2670
|
+
undefined
|
|
2671
|
+
>,
|
|
2672
|
+
v.SchemaWithPipe<
|
|
2673
|
+
readonly [
|
|
2674
|
+
v.StringSchema<undefined>,
|
|
2675
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
2676
|
+
]
|
|
2677
|
+
>,
|
|
2678
|
+
],
|
|
2679
|
+
undefined
|
|
2680
|
+
>,
|
|
2681
|
+
undefined
|
|
2682
|
+
>,
|
|
2683
|
+
undefined
|
|
2684
|
+
>;
|
|
2526
2685
|
},
|
|
2527
2686
|
undefined
|
|
2528
2687
|
>;
|
|
@@ -2535,7 +2694,7 @@ declare const AuthoringStateEntrySchema: v.UnionSchema<
|
|
|
2535
2694
|
[
|
|
2536
2695
|
v.StrictObjectSchema<
|
|
2537
2696
|
{
|
|
2538
|
-
|
|
2697
|
+
type: v.PicklistSchema<
|
|
2539
2698
|
readonly [
|
|
2540
2699
|
"doc.ref",
|
|
2541
2700
|
"doc.refs",
|
|
@@ -2553,15 +2712,45 @@ declare const AuthoringStateEntrySchema: v.UnionSchema<
|
|
|
2553
2712
|
],
|
|
2554
2713
|
`Invalid option: expected one of ${string}`
|
|
2555
2714
|
>;
|
|
2556
|
-
|
|
2715
|
+
name: v.SchemaWithPipe<
|
|
2557
2716
|
readonly [v.StringSchema<undefined>, v.RegexAction<string, string>]
|
|
2558
2717
|
>;
|
|
2559
|
-
|
|
2560
|
-
|
|
2561
|
-
|
|
2718
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
2719
|
+
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
2720
|
+
/**
|
|
2721
|
+
* When true, the caller MUST supply this entry at start (via
|
|
2722
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
2723
|
+
* missing required entry throws rather than silently defaulting to
|
|
2724
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
2725
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
2726
|
+
*/
|
|
2727
|
+
required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2728
|
+
source: v.GenericSchema<SourceInternal>;
|
|
2729
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
2730
|
+
editable: v.OptionalSchema<
|
|
2731
|
+
v.UnionSchema<
|
|
2732
|
+
[
|
|
2733
|
+
v.LiteralSchema<true, undefined>,
|
|
2734
|
+
v.ArraySchema<
|
|
2735
|
+
v.SchemaWithPipe<
|
|
2736
|
+
readonly [
|
|
2737
|
+
v.StringSchema<undefined>,
|
|
2738
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
2739
|
+
]
|
|
2740
|
+
>,
|
|
2741
|
+
undefined
|
|
2742
|
+
>,
|
|
2743
|
+
v.SchemaWithPipe<
|
|
2744
|
+
readonly [
|
|
2745
|
+
v.StringSchema<undefined>,
|
|
2746
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
2747
|
+
]
|
|
2748
|
+
>,
|
|
2749
|
+
],
|
|
2750
|
+
undefined
|
|
2751
|
+
>,
|
|
2562
2752
|
undefined
|
|
2563
2753
|
>;
|
|
2564
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
2565
2754
|
},
|
|
2566
2755
|
undefined
|
|
2567
2756
|
>,
|
|
@@ -3673,7 +3862,7 @@ declare const AuthoringTaskSchema: v.StrictObjectSchema<
|
|
|
3673
3862
|
[
|
|
3674
3863
|
v.StrictObjectSchema<
|
|
3675
3864
|
{
|
|
3676
|
-
|
|
3865
|
+
type: v.PicklistSchema<
|
|
3677
3866
|
readonly [
|
|
3678
3867
|
"doc.ref",
|
|
3679
3868
|
"doc.refs",
|
|
@@ -3691,21 +3880,62 @@ declare const AuthoringTaskSchema: v.StrictObjectSchema<
|
|
|
3691
3880
|
],
|
|
3692
3881
|
`Invalid option: expected one of ${string}`
|
|
3693
3882
|
>;
|
|
3694
|
-
|
|
3883
|
+
name: v.SchemaWithPipe<
|
|
3695
3884
|
readonly [
|
|
3696
3885
|
v.StringSchema<undefined>,
|
|
3697
3886
|
v.RegexAction<string, string>,
|
|
3698
3887
|
]
|
|
3699
3888
|
>;
|
|
3700
|
-
|
|
3889
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
3890
|
+
description: v.OptionalSchema<
|
|
3701
3891
|
v.StringSchema<undefined>,
|
|
3702
3892
|
undefined
|
|
3703
3893
|
>;
|
|
3704
|
-
|
|
3705
|
-
|
|
3894
|
+
/**
|
|
3895
|
+
* When true, the caller MUST supply this entry at start (via
|
|
3896
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
3897
|
+
* missing required entry throws rather than silently defaulting to
|
|
3898
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
3899
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
3900
|
+
*/
|
|
3901
|
+
required: v.OptionalSchema<
|
|
3902
|
+
v.BooleanSchema<undefined>,
|
|
3903
|
+
undefined
|
|
3904
|
+
>;
|
|
3905
|
+
source: v.GenericSchema<SourceInternal>;
|
|
3906
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
3907
|
+
editable: v.OptionalSchema<
|
|
3908
|
+
v.UnionSchema<
|
|
3909
|
+
[
|
|
3910
|
+
v.LiteralSchema<true, undefined>,
|
|
3911
|
+
v.ArraySchema<
|
|
3912
|
+
v.SchemaWithPipe<
|
|
3913
|
+
readonly [
|
|
3914
|
+
v.StringSchema<undefined>,
|
|
3915
|
+
v.MinLengthAction<
|
|
3916
|
+
string,
|
|
3917
|
+
1,
|
|
3918
|
+
"must be a non-empty string"
|
|
3919
|
+
>,
|
|
3920
|
+
]
|
|
3921
|
+
>,
|
|
3922
|
+
undefined
|
|
3923
|
+
>,
|
|
3924
|
+
v.SchemaWithPipe<
|
|
3925
|
+
readonly [
|
|
3926
|
+
v.StringSchema<undefined>,
|
|
3927
|
+
v.MinLengthAction<
|
|
3928
|
+
string,
|
|
3929
|
+
1,
|
|
3930
|
+
"must be a non-empty string"
|
|
3931
|
+
>,
|
|
3932
|
+
]
|
|
3933
|
+
>,
|
|
3934
|
+
],
|
|
3935
|
+
undefined
|
|
3936
|
+
>,
|
|
3706
3937
|
undefined
|
|
3707
3938
|
>;
|
|
3708
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
3709
3939
|
},
|
|
3710
3940
|
undefined
|
|
3711
3941
|
>,
|
|
@@ -4069,6 +4299,22 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
4069
4299
|
]
|
|
4070
4300
|
>;
|
|
4071
4301
|
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
4302
|
+
/**
|
|
4303
|
+
* Whether a human may start this workflow standalone. `'child'` marks a
|
|
4304
|
+
* spawn-only definition — instantiated by a parent via `task.subworkflows`,
|
|
4305
|
+
* never started cold from a picker. Omitted ⇒ `'workflow'` (startable).
|
|
4306
|
+
* Advisory: consumers filter their start pickers on it (see
|
|
4307
|
+
* {@link isStartableDefinition}); the engine does NOT refuse a
|
|
4308
|
+
* `startInstance` on a `'child'` def — load-bearing `required` state is the
|
|
4309
|
+
* runtime backstop.
|
|
4310
|
+
*/
|
|
4311
|
+
role: v.OptionalSchema<
|
|
4312
|
+
v.PicklistSchema<
|
|
4313
|
+
readonly ["workflow", "child"],
|
|
4314
|
+
`Invalid option: expected one of ${string}`
|
|
4315
|
+
>,
|
|
4316
|
+
undefined
|
|
4317
|
+
>;
|
|
4072
4318
|
/** Reference field: named for the target, holds the stage's `name`. */
|
|
4073
4319
|
initialStage: v.SchemaWithPipe<
|
|
4074
4320
|
readonly [
|
|
@@ -4083,7 +4329,7 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
4083
4329
|
[
|
|
4084
4330
|
v.StrictObjectSchema<
|
|
4085
4331
|
{
|
|
4086
|
-
|
|
4332
|
+
type: v.PicklistSchema<
|
|
4087
4333
|
readonly [
|
|
4088
4334
|
"doc.ref",
|
|
4089
4335
|
"doc.refs",
|
|
@@ -4101,21 +4347,62 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
4101
4347
|
],
|
|
4102
4348
|
`Invalid option: expected one of ${string}`
|
|
4103
4349
|
>;
|
|
4104
|
-
|
|
4350
|
+
name: v.SchemaWithPipe<
|
|
4105
4351
|
readonly [
|
|
4106
4352
|
v.StringSchema<undefined>,
|
|
4107
4353
|
v.RegexAction<string, string>,
|
|
4108
4354
|
]
|
|
4109
4355
|
>;
|
|
4110
|
-
|
|
4356
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
4357
|
+
description: v.OptionalSchema<
|
|
4111
4358
|
v.StringSchema<undefined>,
|
|
4112
4359
|
undefined
|
|
4113
4360
|
>;
|
|
4114
|
-
|
|
4115
|
-
|
|
4361
|
+
/**
|
|
4362
|
+
* When true, the caller MUST supply this entry at start (via
|
|
4363
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
4364
|
+
* missing required entry throws rather than silently defaulting to
|
|
4365
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
4366
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
4367
|
+
*/
|
|
4368
|
+
required: v.OptionalSchema<
|
|
4369
|
+
v.BooleanSchema<undefined>,
|
|
4370
|
+
undefined
|
|
4371
|
+
>;
|
|
4372
|
+
source: v.GenericSchema<SourceInternal>;
|
|
4373
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
4374
|
+
editable: v.OptionalSchema<
|
|
4375
|
+
v.UnionSchema<
|
|
4376
|
+
[
|
|
4377
|
+
v.LiteralSchema<true, undefined>,
|
|
4378
|
+
v.ArraySchema<
|
|
4379
|
+
v.SchemaWithPipe<
|
|
4380
|
+
readonly [
|
|
4381
|
+
v.StringSchema<undefined>,
|
|
4382
|
+
v.MinLengthAction<
|
|
4383
|
+
string,
|
|
4384
|
+
1,
|
|
4385
|
+
"must be a non-empty string"
|
|
4386
|
+
>,
|
|
4387
|
+
]
|
|
4388
|
+
>,
|
|
4389
|
+
undefined
|
|
4390
|
+
>,
|
|
4391
|
+
v.SchemaWithPipe<
|
|
4392
|
+
readonly [
|
|
4393
|
+
v.StringSchema<undefined>,
|
|
4394
|
+
v.MinLengthAction<
|
|
4395
|
+
string,
|
|
4396
|
+
1,
|
|
4397
|
+
"must be a non-empty string"
|
|
4398
|
+
>,
|
|
4399
|
+
]
|
|
4400
|
+
>,
|
|
4401
|
+
],
|
|
4402
|
+
undefined
|
|
4403
|
+
>,
|
|
4116
4404
|
undefined
|
|
4117
4405
|
>;
|
|
4118
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
4119
4406
|
},
|
|
4120
4407
|
undefined
|
|
4121
4408
|
>,
|
|
@@ -5411,7 +5698,7 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
5411
5698
|
[
|
|
5412
5699
|
v.StrictObjectSchema<
|
|
5413
5700
|
{
|
|
5414
|
-
|
|
5701
|
+
type: v.PicklistSchema<
|
|
5415
5702
|
readonly [
|
|
5416
5703
|
"doc.ref",
|
|
5417
5704
|
"doc.refs",
|
|
@@ -5429,21 +5716,65 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
5429
5716
|
],
|
|
5430
5717
|
`Invalid option: expected one of ${string}`
|
|
5431
5718
|
>;
|
|
5432
|
-
|
|
5719
|
+
name: v.SchemaWithPipe<
|
|
5433
5720
|
readonly [
|
|
5434
5721
|
v.StringSchema<undefined>,
|
|
5435
5722
|
v.RegexAction<string, string>,
|
|
5436
5723
|
]
|
|
5437
5724
|
>;
|
|
5438
|
-
|
|
5725
|
+
title: v.OptionalSchema<
|
|
5439
5726
|
v.StringSchema<undefined>,
|
|
5440
5727
|
undefined
|
|
5441
5728
|
>;
|
|
5442
|
-
|
|
5729
|
+
description: v.OptionalSchema<
|
|
5443
5730
|
v.StringSchema<undefined>,
|
|
5444
5731
|
undefined
|
|
5445
5732
|
>;
|
|
5446
|
-
|
|
5733
|
+
/**
|
|
5734
|
+
* When true, the caller MUST supply this entry at start (via
|
|
5735
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
5736
|
+
* missing required entry throws rather than silently defaulting to
|
|
5737
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
5738
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
5739
|
+
*/
|
|
5740
|
+
required: v.OptionalSchema<
|
|
5741
|
+
v.BooleanSchema<undefined>,
|
|
5742
|
+
undefined
|
|
5743
|
+
>;
|
|
5744
|
+
source: v.GenericSchema<SourceInternal>;
|
|
5745
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
5746
|
+
editable: v.OptionalSchema<
|
|
5747
|
+
v.UnionSchema<
|
|
5748
|
+
[
|
|
5749
|
+
v.LiteralSchema<true, undefined>,
|
|
5750
|
+
v.ArraySchema<
|
|
5751
|
+
v.SchemaWithPipe<
|
|
5752
|
+
readonly [
|
|
5753
|
+
v.StringSchema<undefined>,
|
|
5754
|
+
v.MinLengthAction<
|
|
5755
|
+
string,
|
|
5756
|
+
1,
|
|
5757
|
+
"must be a non-empty string"
|
|
5758
|
+
>,
|
|
5759
|
+
]
|
|
5760
|
+
>,
|
|
5761
|
+
undefined
|
|
5762
|
+
>,
|
|
5763
|
+
v.SchemaWithPipe<
|
|
5764
|
+
readonly [
|
|
5765
|
+
v.StringSchema<undefined>,
|
|
5766
|
+
v.MinLengthAction<
|
|
5767
|
+
string,
|
|
5768
|
+
1,
|
|
5769
|
+
"must be a non-empty string"
|
|
5770
|
+
>,
|
|
5771
|
+
]
|
|
5772
|
+
>,
|
|
5773
|
+
],
|
|
5774
|
+
undefined
|
|
5775
|
+
>,
|
|
5776
|
+
undefined
|
|
5777
|
+
>;
|
|
5447
5778
|
},
|
|
5448
5779
|
undefined
|
|
5449
5780
|
>,
|
|
@@ -6023,7 +6354,7 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6023
6354
|
[
|
|
6024
6355
|
v.StrictObjectSchema<
|
|
6025
6356
|
{
|
|
6026
|
-
|
|
6357
|
+
type: v.PicklistSchema<
|
|
6027
6358
|
readonly [
|
|
6028
6359
|
"doc.ref",
|
|
6029
6360
|
"doc.refs",
|
|
@@ -6041,21 +6372,65 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6041
6372
|
],
|
|
6042
6373
|
`Invalid option: expected one of ${string}`
|
|
6043
6374
|
>;
|
|
6044
|
-
|
|
6375
|
+
name: v.SchemaWithPipe<
|
|
6045
6376
|
readonly [
|
|
6046
6377
|
v.StringSchema<undefined>,
|
|
6047
6378
|
v.RegexAction<string, string>,
|
|
6048
6379
|
]
|
|
6049
6380
|
>;
|
|
6050
|
-
|
|
6381
|
+
title: v.OptionalSchema<
|
|
6051
6382
|
v.StringSchema<undefined>,
|
|
6052
6383
|
undefined
|
|
6053
6384
|
>;
|
|
6054
|
-
|
|
6385
|
+
description: v.OptionalSchema<
|
|
6055
6386
|
v.StringSchema<undefined>,
|
|
6056
6387
|
undefined
|
|
6057
6388
|
>;
|
|
6058
|
-
|
|
6389
|
+
/**
|
|
6390
|
+
* When true, the caller MUST supply this entry at start (via
|
|
6391
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
6392
|
+
* missing required entry throws rather than silently defaulting to
|
|
6393
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
6394
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
6395
|
+
*/
|
|
6396
|
+
required: v.OptionalSchema<
|
|
6397
|
+
v.BooleanSchema<undefined>,
|
|
6398
|
+
undefined
|
|
6399
|
+
>;
|
|
6400
|
+
source: v.GenericSchema<SourceInternal>;
|
|
6401
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
6402
|
+
editable: v.OptionalSchema<
|
|
6403
|
+
v.UnionSchema<
|
|
6404
|
+
[
|
|
6405
|
+
v.LiteralSchema<true, undefined>,
|
|
6406
|
+
v.ArraySchema<
|
|
6407
|
+
v.SchemaWithPipe<
|
|
6408
|
+
readonly [
|
|
6409
|
+
v.StringSchema<undefined>,
|
|
6410
|
+
v.MinLengthAction<
|
|
6411
|
+
string,
|
|
6412
|
+
1,
|
|
6413
|
+
"must be a non-empty string"
|
|
6414
|
+
>,
|
|
6415
|
+
]
|
|
6416
|
+
>,
|
|
6417
|
+
undefined
|
|
6418
|
+
>,
|
|
6419
|
+
v.SchemaWithPipe<
|
|
6420
|
+
readonly [
|
|
6421
|
+
v.StringSchema<undefined>,
|
|
6422
|
+
v.MinLengthAction<
|
|
6423
|
+
string,
|
|
6424
|
+
1,
|
|
6425
|
+
"must be a non-empty string"
|
|
6426
|
+
>,
|
|
6427
|
+
]
|
|
6428
|
+
>,
|
|
6429
|
+
],
|
|
6430
|
+
undefined
|
|
6431
|
+
>,
|
|
6432
|
+
undefined
|
|
6433
|
+
>;
|
|
6059
6434
|
},
|
|
6060
6435
|
undefined
|
|
6061
6436
|
>,
|
|
@@ -6086,6 +6461,54 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6086
6461
|
>,
|
|
6087
6462
|
undefined
|
|
6088
6463
|
>;
|
|
6464
|
+
/**
|
|
6465
|
+
* Tighten-only editability overrides for the time this stage holds, keyed
|
|
6466
|
+
* by an in-scope slot name. The slot's own `editable` is the ceiling; a
|
|
6467
|
+
* stage value is ANDed with it at runtime, so an override can only NARROW
|
|
6468
|
+
* (never open a slot the baseline left closed). An unlisted slot inherits
|
|
6469
|
+
* its baseline.
|
|
6470
|
+
*/
|
|
6471
|
+
editable: v.OptionalSchema<
|
|
6472
|
+
v.RecordSchema<
|
|
6473
|
+
v.SchemaWithPipe<
|
|
6474
|
+
readonly [
|
|
6475
|
+
v.StringSchema<undefined>,
|
|
6476
|
+
v.RegexAction<string, string>,
|
|
6477
|
+
]
|
|
6478
|
+
>,
|
|
6479
|
+
v.UnionSchema<
|
|
6480
|
+
[
|
|
6481
|
+
v.LiteralSchema<true, undefined>,
|
|
6482
|
+
v.ArraySchema<
|
|
6483
|
+
v.SchemaWithPipe<
|
|
6484
|
+
readonly [
|
|
6485
|
+
v.StringSchema<undefined>,
|
|
6486
|
+
v.MinLengthAction<
|
|
6487
|
+
string,
|
|
6488
|
+
1,
|
|
6489
|
+
"must be a non-empty string"
|
|
6490
|
+
>,
|
|
6491
|
+
]
|
|
6492
|
+
>,
|
|
6493
|
+
undefined
|
|
6494
|
+
>,
|
|
6495
|
+
v.SchemaWithPipe<
|
|
6496
|
+
readonly [
|
|
6497
|
+
v.StringSchema<undefined>,
|
|
6498
|
+
v.MinLengthAction<
|
|
6499
|
+
string,
|
|
6500
|
+
1,
|
|
6501
|
+
"must be a non-empty string"
|
|
6502
|
+
>,
|
|
6503
|
+
]
|
|
6504
|
+
>,
|
|
6505
|
+
],
|
|
6506
|
+
undefined
|
|
6507
|
+
>,
|
|
6508
|
+
undefined
|
|
6509
|
+
>,
|
|
6510
|
+
undefined
|
|
6511
|
+
>;
|
|
6089
6512
|
},
|
|
6090
6513
|
undefined
|
|
6091
6514
|
>,
|
|
@@ -6426,7 +6849,9 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6426
6849
|
name: string;
|
|
6427
6850
|
title?: string | undefined;
|
|
6428
6851
|
description?: string | undefined;
|
|
6852
|
+
required?: boolean | undefined;
|
|
6429
6853
|
source: SourceInternal;
|
|
6854
|
+
editable?: string | true | string[] | undefined;
|
|
6430
6855
|
}
|
|
6431
6856
|
| {
|
|
6432
6857
|
type: "claim";
|
|
@@ -6567,7 +6992,9 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6567
6992
|
name: string;
|
|
6568
6993
|
title?: string | undefined;
|
|
6569
6994
|
description?: string | undefined;
|
|
6995
|
+
required?: boolean | undefined;
|
|
6570
6996
|
source: SourceInternal;
|
|
6997
|
+
editable?: string | true | string[] | undefined;
|
|
6571
6998
|
}
|
|
6572
6999
|
| {
|
|
6573
7000
|
type: "claim";
|
|
@@ -6577,6 +7004,11 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6577
7004
|
}
|
|
6578
7005
|
)[]
|
|
6579
7006
|
| undefined;
|
|
7007
|
+
editable?:
|
|
7008
|
+
| {
|
|
7009
|
+
[x: string]: string | true | string[];
|
|
7010
|
+
}
|
|
7011
|
+
| undefined;
|
|
6580
7012
|
}[],
|
|
6581
7013
|
1,
|
|
6582
7014
|
"must declare at least one stage"
|
|
@@ -6603,6 +7035,37 @@ declare const AuthoringWorkflowSchema: v.StrictObjectSchema<
|
|
|
6603
7035
|
>,
|
|
6604
7036
|
undefined
|
|
6605
7037
|
>;
|
|
7038
|
+
/** Role aliasing for this definition — see {@link RoleAliasesSchema}. */
|
|
7039
|
+
roleAliases: v.OptionalSchema<
|
|
7040
|
+
v.RecordSchema<
|
|
7041
|
+
v.SchemaWithPipe<
|
|
7042
|
+
readonly [
|
|
7043
|
+
v.StringSchema<undefined>,
|
|
7044
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
7045
|
+
]
|
|
7046
|
+
>,
|
|
7047
|
+
v.SchemaWithPipe<
|
|
7048
|
+
readonly [
|
|
7049
|
+
v.ArraySchema<
|
|
7050
|
+
v.SchemaWithPipe<
|
|
7051
|
+
readonly [
|
|
7052
|
+
v.StringSchema<undefined>,
|
|
7053
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
7054
|
+
]
|
|
7055
|
+
>,
|
|
7056
|
+
undefined
|
|
7057
|
+
>,
|
|
7058
|
+
v.MinLengthAction<
|
|
7059
|
+
string[],
|
|
7060
|
+
1,
|
|
7061
|
+
"a role alias must list at least one fulfilling role"
|
|
7062
|
+
>,
|
|
7063
|
+
]
|
|
7064
|
+
>,
|
|
7065
|
+
undefined
|
|
7066
|
+
>,
|
|
7067
|
+
undefined
|
|
7068
|
+
>;
|
|
6606
7069
|
},
|
|
6607
7070
|
undefined
|
|
6608
7071
|
>;
|
|
@@ -6751,6 +7214,30 @@ export declare function computeDiffEntries(
|
|
|
6751
7214
|
target: DeployTarget,
|
|
6752
7215
|
): Promise<DiffEntry[]>;
|
|
6753
7216
|
|
|
7217
|
+
/**
|
|
7218
|
+
* Edit-seam twin of {@link ConcurrentFireActionError}: an `editState` commit
|
|
7219
|
+
* lost the optimistic-locking race on every attempt. Same contract — re-read
|
|
7220
|
+
* and retry, or investigate a write storm; nothing committed on the final try.
|
|
7221
|
+
*/
|
|
7222
|
+
export declare class ConcurrentEditStateError extends Error {
|
|
7223
|
+
readonly instanceId: string;
|
|
7224
|
+
readonly target: {
|
|
7225
|
+
scope: StateScope;
|
|
7226
|
+
state: string;
|
|
7227
|
+
task?: string;
|
|
7228
|
+
};
|
|
7229
|
+
readonly attempts: number;
|
|
7230
|
+
constructor(args: {
|
|
7231
|
+
instanceId: string;
|
|
7232
|
+
target: {
|
|
7233
|
+
scope: StateScope;
|
|
7234
|
+
state: string;
|
|
7235
|
+
task?: string;
|
|
7236
|
+
};
|
|
7237
|
+
attempts: number;
|
|
7238
|
+
});
|
|
7239
|
+
}
|
|
7240
|
+
|
|
6754
7241
|
/**
|
|
6755
7242
|
* Thrown when a `fireAction` commit loses the optimistic-locking race on
|
|
6756
7243
|
* all {@link CONCURRENT_FIRE_ACTION_MAX_ATTEMPTS} attempts — every reload +
|
|
@@ -7188,6 +7675,133 @@ export declare interface DrainEffectsResult {
|
|
|
7188
7675
|
skipped: PendingEffect[];
|
|
7189
7676
|
}
|
|
7190
7677
|
|
|
7678
|
+
export declare type Editable = v.InferOutput<typeof StoredEditableSchema>;
|
|
7679
|
+
|
|
7680
|
+
/**
|
|
7681
|
+
* One declared-editable slot in the current scope, projected for an actor: its
|
|
7682
|
+
* resolved value, whether this actor may edit it now (advisory), and the
|
|
7683
|
+
* provenance of the current value read off `opApplied` history. The reactive
|
|
7684
|
+
* surface a consumer renders as an inline field (the field widget itself is
|
|
7685
|
+
* out of scope here — see the slot-component work).
|
|
7686
|
+
*/
|
|
7687
|
+
export declare interface EditableSlotEvaluation {
|
|
7688
|
+
scope: StateScope;
|
|
7689
|
+
/** Present iff `scope === "task"`. */
|
|
7690
|
+
task?: TaskName;
|
|
7691
|
+
name: string;
|
|
7692
|
+
type: StateKind;
|
|
7693
|
+
title?: string;
|
|
7694
|
+
/** Current resolved value; `undefined` until the slot is first resolved. */
|
|
7695
|
+
value: unknown;
|
|
7696
|
+
/** Whether THIS actor may edit the slot right now (window + predicate + guard). */
|
|
7697
|
+
editable: boolean;
|
|
7698
|
+
/** Present iff `editable === false`. */
|
|
7699
|
+
disabledReason?: EditDisabledReason;
|
|
7700
|
+
/** Actor who last wrote the slot (latest `opApplied`); absent if never written. */
|
|
7701
|
+
setBy?: Actor;
|
|
7702
|
+
/** When the slot was last written (ISO); absent if never written. */
|
|
7703
|
+
setAt?: string;
|
|
7704
|
+
}
|
|
7705
|
+
|
|
7706
|
+
/**
|
|
7707
|
+
* Why an editable slot can't be edited by this actor right now — the edit-seam
|
|
7708
|
+
* twin of {@link DisabledReason}. First failing gate wins: the slot must be
|
|
7709
|
+
* declared editable, its scope window open, no lake guard denying the instance
|
|
7710
|
+
* write, and the who-may-edit predicate satisfied. Reuses the shared
|
|
7711
|
+
* `mutation-guard-denied` shape — an edit is the same instance-doc `update` an
|
|
7712
|
+
* action commit performs, so the same guard pre-flight applies.
|
|
7713
|
+
*/
|
|
7714
|
+
export declare type EditDisabledReason =
|
|
7715
|
+
| {
|
|
7716
|
+
kind: "not-editable";
|
|
7717
|
+
}
|
|
7718
|
+
| {
|
|
7719
|
+
kind: "instance-completed";
|
|
7720
|
+
completedAt: string;
|
|
7721
|
+
}
|
|
7722
|
+
| {
|
|
7723
|
+
/** The slot's scope window is closed: a task-scope slot whose task isn't
|
|
7724
|
+
* active, or otherwise out of its editable window. */
|
|
7725
|
+
kind: "edit-window-closed";
|
|
7726
|
+
detail: string;
|
|
7727
|
+
}
|
|
7728
|
+
| {
|
|
7729
|
+
/** The slot's effective `editable` predicate evaluated falsy for this
|
|
7730
|
+
* actor (a role/predicate miss; the stage tighten-override is folded in). */
|
|
7731
|
+
kind: "editor-not-permitted";
|
|
7732
|
+
predicate: string;
|
|
7733
|
+
}
|
|
7734
|
+
| Extract<
|
|
7735
|
+
DisabledReason,
|
|
7736
|
+
{
|
|
7737
|
+
kind: "mutation-guard-denied";
|
|
7738
|
+
}
|
|
7739
|
+
>;
|
|
7740
|
+
|
|
7741
|
+
/**
|
|
7742
|
+
* The generic edit seam (EDEX-1319). `editState` writes a declared-editable
|
|
7743
|
+
* slot directly — reassign, reschedule, claim-by-hand, append to a log —
|
|
7744
|
+
* without a bespoke action per field. It is NOT a raw patch: the edit applies
|
|
7745
|
+
* as a `state.*` op through the shared op path (so it stamps `opApplied`
|
|
7746
|
+
* provenance + history), gates on the slot's declared editability the same way
|
|
7747
|
+
* an action gates on its filter, then refreshes the stage's guards and lets the
|
|
7748
|
+
* caller cascade. Editing a value a transition reads can and should move the
|
|
7749
|
+
* instance — that rippling is intended.
|
|
7750
|
+
*
|
|
7751
|
+
* Gating is ONE mechanism (advisory, like every engine check): the slot's
|
|
7752
|
+
* effective `editable` predicate over the rendered scope. The lake ACL + guards
|
|
7753
|
+
* are the only hard locks.
|
|
7754
|
+
*/
|
|
7755
|
+
export declare type EditMode = "set" | "append" | "unset";
|
|
7756
|
+
|
|
7757
|
+
export declare interface EditStateArgs extends OperationArgs {
|
|
7758
|
+
/**
|
|
7759
|
+
* Which declared-editable slot to write. Omit `scope` to resolve lexically
|
|
7760
|
+
* (a `task` implies task scope; otherwise the nearest declaring scope, stage
|
|
7761
|
+
* before workflow). `task` is required to address a task-scope slot.
|
|
7762
|
+
*/
|
|
7763
|
+
target: EditStateTarget;
|
|
7764
|
+
/**
|
|
7765
|
+
* How to write: `set` replaces the value (reassign / reschedule), `append`
|
|
7766
|
+
* adds a row to an array slot (a running log / checklist), `unset` clears it.
|
|
7767
|
+
* Default `set`.
|
|
7768
|
+
*/
|
|
7769
|
+
mode?: EditMode;
|
|
7770
|
+
/**
|
|
7771
|
+
* The new value (for `set`) or row (for `append`), as plain JSON matching the
|
|
7772
|
+
* slot's kind. Validated against the slot kind in the op path; omit for
|
|
7773
|
+
* `unset`.
|
|
7774
|
+
*/
|
|
7775
|
+
value?: unknown;
|
|
7776
|
+
}
|
|
7777
|
+
|
|
7778
|
+
/** Edit-seam twin of {@link ActionDisabledError}: thrown by `editState` when
|
|
7779
|
+
* the slot can't be edited by the caller. Carries the structured reason. */
|
|
7780
|
+
export declare class EditStateDeniedError extends Error {
|
|
7781
|
+
readonly reason: EditDisabledReason;
|
|
7782
|
+
readonly target: {
|
|
7783
|
+
scope: StateScope;
|
|
7784
|
+
state: string;
|
|
7785
|
+
task?: string;
|
|
7786
|
+
};
|
|
7787
|
+
constructor(args: {
|
|
7788
|
+
target: {
|
|
7789
|
+
scope: StateScope;
|
|
7790
|
+
state: string;
|
|
7791
|
+
task?: string;
|
|
7792
|
+
};
|
|
7793
|
+
reason: EditDisabledReason;
|
|
7794
|
+
});
|
|
7795
|
+
}
|
|
7796
|
+
|
|
7797
|
+
export declare interface EditStateTarget {
|
|
7798
|
+
/** Omit to resolve lexically (task slot if `task` set, else stage then workflow). */
|
|
7799
|
+
scope?: StateScope;
|
|
7800
|
+
state: string;
|
|
7801
|
+
/** Required to address a task-scope slot. */
|
|
7802
|
+
task?: string;
|
|
7803
|
+
}
|
|
7804
|
+
|
|
7191
7805
|
export declare type Effect = v.InferOutput<typeof EffectSchema>;
|
|
7192
7806
|
|
|
7193
7807
|
/**
|
|
@@ -7373,6 +7987,9 @@ export declare interface Engine {
|
|
|
7373
7987
|
) => Promise<DeployDefinitionsResult>;
|
|
7374
7988
|
startInstance: (args: Bound<StartInstanceArgs>) => Promise<WorkflowInstance>;
|
|
7375
7989
|
fireAction: (args: Bound<FireActionArgs>) => Promise<DispatchResult>;
|
|
7990
|
+
/** Edit a declared-editable state slot directly (the generic edit seam):
|
|
7991
|
+
* reassign / reschedule / claim-by-hand / append-to-log, then cascade. */
|
|
7992
|
+
editState: (args: Bound<EditStateArgs>) => Promise<DispatchResult>;
|
|
7376
7993
|
completeEffect: (args: Bound<CompleteEffectArgs>) => Promise<DispatchResult>;
|
|
7377
7994
|
tick: (args: Bound<OperationArgs>) => Promise<DispatchResult>;
|
|
7378
7995
|
evaluateInstance: (
|
|
@@ -8156,10 +8773,16 @@ export declare type HistoryEntry =
|
|
|
8156
8773
|
_type: "opApplied";
|
|
8157
8774
|
at: string;
|
|
8158
8775
|
stage: StageName;
|
|
8159
|
-
/** The boundary that ran the op
|
|
8776
|
+
/** The boundary that ran the op. For an action/transition/activation,
|
|
8777
|
+
* exactly one of task/action/transition is set; for a direct edit
|
|
8778
|
+
* (the edit seam), `edit` is set and `task` carries the slot's task when
|
|
8779
|
+
* the edited slot is task-scope. */
|
|
8160
8780
|
task?: TaskName;
|
|
8161
8781
|
action?: ActionName;
|
|
8162
8782
|
transition?: string;
|
|
8783
|
+
/** Set when the op was a direct edit through the edit seam (`editState`),
|
|
8784
|
+
* not an action/transition/activation. */
|
|
8785
|
+
edit?: true;
|
|
8163
8786
|
/** The op's `type` (e.g. `state.set`). */
|
|
8164
8787
|
opType: string;
|
|
8165
8788
|
/** State reference the op targeted (omitted for `status.set`). */
|
|
@@ -8245,6 +8868,13 @@ export declare interface InstanceSession {
|
|
|
8245
8868
|
action: string;
|
|
8246
8869
|
params?: Record<string, unknown>;
|
|
8247
8870
|
}): Promise<DispatchResult>;
|
|
8871
|
+
/** Edit a declared-editable slot against the held content (the generic edit
|
|
8872
|
+
* seam), gated on the held projection, then cascade. */
|
|
8873
|
+
editState(args: {
|
|
8874
|
+
target: EditStateTarget;
|
|
8875
|
+
mode?: EditMode;
|
|
8876
|
+
value?: unknown;
|
|
8877
|
+
}): Promise<DispatchResult>;
|
|
8248
8878
|
}
|
|
8249
8879
|
|
|
8250
8880
|
/**
|
|
@@ -8261,6 +8891,18 @@ export declare function isDefinitionUnchanged(
|
|
|
8261
8891
|
/** Type filter for GDR shape. */
|
|
8262
8892
|
export declare function isGdr(value: unknown): value is GlobalDocumentReference;
|
|
8263
8893
|
|
|
8894
|
+
/**
|
|
8895
|
+
* Whether a human may start this definition standalone (the default). A
|
|
8896
|
+
* `role: 'child'` definition is spawn-only — instantiated by a parent via
|
|
8897
|
+
* `task.subworkflows`, so consumers exclude it from top-level start pickers.
|
|
8898
|
+
* Advisory: the engine does not enforce it (see the `required`-state backstop
|
|
8899
|
+
* for load-bearing init slots). Accepts any definition-shaped value (authored,
|
|
8900
|
+
* stored, deployed, or a projected list row).
|
|
8901
|
+
*/
|
|
8902
|
+
export declare function isStartableDefinition(definition: {
|
|
8903
|
+
role?: WorkflowRole | undefined;
|
|
8904
|
+
}): boolean;
|
|
8905
|
+
|
|
8264
8906
|
/**
|
|
8265
8907
|
* A stage with no transitions out IS terminal — structural, not declared.
|
|
8266
8908
|
* Reaching one completes the instance.
|
|
@@ -8546,6 +9188,20 @@ export declare interface ParsedGdr {
|
|
|
8546
9188
|
*/
|
|
8547
9189
|
export declare function parseGdr(uri: string): ParsedGdr;
|
|
8548
9190
|
|
|
9191
|
+
/**
|
|
9192
|
+
* A stage's multi-guard deploy failed *after* at least one guard already landed.
|
|
9193
|
+
* Those partial locks can't be cleanly undone (guard docs have no transactional
|
|
9194
|
+
* deploy). Inside the engine {@link deployOrRollback} rolls the state move back
|
|
9195
|
+
* and escalates this to a loud {@link WorkflowStateDivergedError}; a caller that
|
|
9196
|
+
* invokes {@link deployStageGuards} directly (without that rollback wrapper) can
|
|
9197
|
+
* also see it, so it's exported to be catchable by type.
|
|
9198
|
+
*/
|
|
9199
|
+
export declare class PartialGuardDeployError extends Error {
|
|
9200
|
+
readonly stageName: string;
|
|
9201
|
+
readonly deployed: number;
|
|
9202
|
+
constructor(args: { stageName: string; deployed: number; cause: unknown });
|
|
9203
|
+
}
|
|
9204
|
+
|
|
8549
9205
|
export declare interface PendingEffect {
|
|
8550
9206
|
_key: string;
|
|
8551
9207
|
_type?: "pendingEffect";
|
|
@@ -8670,6 +9326,28 @@ export declare type RemediationVerb =
|
|
|
8670
9326
|
| "set-stage"
|
|
8671
9327
|
| "abort";
|
|
8672
9328
|
|
|
9329
|
+
/**
|
|
9330
|
+
* Thrown when a workflow is started (or a child spawned) without a value for
|
|
9331
|
+
* a state entry marked `required`. Mirrors {@link ActionParamsInvalidError}:
|
|
9332
|
+
* the engine has NOT created the instance — a missing load-bearing slot
|
|
9333
|
+
* (e.g. the subject of a review) screams here rather than silently defaulting
|
|
9334
|
+
* to `null`/`[]` and birthing a half-formed instance mid-process.
|
|
9335
|
+
*/
|
|
9336
|
+
export declare class RequiredStateNotProvidedError extends Error {
|
|
9337
|
+
readonly definition?: string;
|
|
9338
|
+
readonly missing: {
|
|
9339
|
+
name: string;
|
|
9340
|
+
type: string;
|
|
9341
|
+
}[];
|
|
9342
|
+
constructor(args: {
|
|
9343
|
+
definition?: string;
|
|
9344
|
+
missing: {
|
|
9345
|
+
name: string;
|
|
9346
|
+
type: string;
|
|
9347
|
+
}[];
|
|
9348
|
+
});
|
|
9349
|
+
}
|
|
9350
|
+
|
|
8673
9351
|
/**
|
|
8674
9352
|
* Resolve the engine's `WorkflowAccess` for a client. Override wins
|
|
8675
9353
|
* outright; otherwise both halves are fetched in parallel and
|
|
@@ -8761,6 +9439,60 @@ export declare function resourceFromParsed(parsed: ParsedGdr): WorkflowResource;
|
|
|
8761
9439
|
*/
|
|
8762
9440
|
export declare function retractStageGuards(args: StageGuardArgs): Promise<void>;
|
|
8763
9441
|
|
|
9442
|
+
export declare type RoleAliases = v.InferOutput<typeof RoleAliasesSchema>;
|
|
9443
|
+
|
|
9444
|
+
/**
|
|
9445
|
+
* Role aliasing — the "can be fulfilled by" map, an authoring convenience.
|
|
9446
|
+
* A `roles` gate (or an `assignees` entry) names the role the author writes;
|
|
9447
|
+
* but the SAME capability is often carried by different role names depending
|
|
9448
|
+
* on how a given project deploys its Content Lake roles, and several roles may
|
|
9449
|
+
* legitimately do the job. Rather than enumerate every equivalent role inline
|
|
9450
|
+
* in each gate — or fork the definition per deployment — declare once here
|
|
9451
|
+
* which other roles also fulfill it.
|
|
9452
|
+
*
|
|
9453
|
+
* Each key is a role a gate/assignee names; its value lists the roles that
|
|
9454
|
+
* also satisfy it. The reserved key `"*"` lists roles that fulfill ANY gate
|
|
9455
|
+
* (e.g. `"*": ["administrator"]` — whatever this deployment's broad role is).
|
|
9456
|
+
*
|
|
9457
|
+
* Applied as an in-place expansion of the REQUIRED side, never the actor's
|
|
9458
|
+
* roles: the `roles` gate bakes the expanded membership into its desugared
|
|
9459
|
+
* GROQ at define time; `$assigned` expands the assignee's role at match time
|
|
9460
|
+
* (see {@link expandRequiredRoles}). Carried into the stored definition for
|
|
9461
|
+
* that runtime half.
|
|
9462
|
+
*
|
|
9463
|
+
* Advisory, like every engine gate — an alias only predicts what the
|
|
9464
|
+
* deployment's Content Lake ACLs already allow, it never grants access. An
|
|
9465
|
+
* alias the lake won't honor makes the gate predict "allowed" for a write the
|
|
9466
|
+
* lake then rejects, so keep it true to what's actually deployed.
|
|
9467
|
+
*/
|
|
9468
|
+
declare const RoleAliasesSchema: v.RecordSchema<
|
|
9469
|
+
v.SchemaWithPipe<
|
|
9470
|
+
readonly [
|
|
9471
|
+
v.StringSchema<undefined>,
|
|
9472
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
9473
|
+
]
|
|
9474
|
+
>,
|
|
9475
|
+
v.SchemaWithPipe<
|
|
9476
|
+
readonly [
|
|
9477
|
+
v.ArraySchema<
|
|
9478
|
+
v.SchemaWithPipe<
|
|
9479
|
+
readonly [
|
|
9480
|
+
v.StringSchema<undefined>,
|
|
9481
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
9482
|
+
]
|
|
9483
|
+
>,
|
|
9484
|
+
undefined
|
|
9485
|
+
>,
|
|
9486
|
+
v.MinLengthAction<
|
|
9487
|
+
string[],
|
|
9488
|
+
1,
|
|
9489
|
+
"a role alias must list at least one fulfilling role"
|
|
9490
|
+
>,
|
|
9491
|
+
]
|
|
9492
|
+
>,
|
|
9493
|
+
undefined
|
|
9494
|
+
>;
|
|
9495
|
+
|
|
8764
9496
|
export declare interface SetStageArgs extends OperationArgs {
|
|
8765
9497
|
/** Stage id to force the instance into. */
|
|
8766
9498
|
targetStage: string;
|
|
@@ -9002,7 +9734,7 @@ export declare type StateEntry = v.InferOutput<typeof StateEntrySchema>;
|
|
|
9002
9734
|
|
|
9003
9735
|
declare const StateEntrySchema: v.StrictObjectSchema<
|
|
9004
9736
|
{
|
|
9005
|
-
|
|
9737
|
+
type: v.PicklistSchema<
|
|
9006
9738
|
readonly [
|
|
9007
9739
|
"doc.ref",
|
|
9008
9740
|
"doc.refs",
|
|
@@ -9020,15 +9752,36 @@ declare const StateEntrySchema: v.StrictObjectSchema<
|
|
|
9020
9752
|
],
|
|
9021
9753
|
`Invalid option: expected one of ${string}`
|
|
9022
9754
|
>;
|
|
9023
|
-
|
|
9755
|
+
name: v.SchemaWithPipe<
|
|
9024
9756
|
readonly [v.StringSchema<undefined>, v.RegexAction<string, string>]
|
|
9025
9757
|
>;
|
|
9026
|
-
|
|
9027
|
-
|
|
9028
|
-
|
|
9758
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
9759
|
+
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
9760
|
+
/**
|
|
9761
|
+
* When true, the caller MUST supply this entry at start (via
|
|
9762
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
9763
|
+
* missing required entry throws rather than silently defaulting to
|
|
9764
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
9765
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
9766
|
+
*/
|
|
9767
|
+
required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
9768
|
+
source: v.GenericSchema<SourceInternal>;
|
|
9769
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
9770
|
+
editable: v.OptionalSchema<
|
|
9771
|
+
v.UnionSchema<
|
|
9772
|
+
[
|
|
9773
|
+
v.LiteralSchema<true, undefined>,
|
|
9774
|
+
v.SchemaWithPipe<
|
|
9775
|
+
readonly [
|
|
9776
|
+
v.StringSchema<undefined>,
|
|
9777
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
9778
|
+
]
|
|
9779
|
+
>,
|
|
9780
|
+
],
|
|
9781
|
+
undefined
|
|
9782
|
+
>,
|
|
9029
9783
|
undefined
|
|
9030
9784
|
>;
|
|
9031
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
9032
9785
|
},
|
|
9033
9786
|
undefined
|
|
9034
9787
|
>;
|
|
@@ -9330,6 +10083,28 @@ declare const StoredActionSchema: v.StrictObjectSchema<
|
|
|
9330
10083
|
undefined
|
|
9331
10084
|
>;
|
|
9332
10085
|
|
|
10086
|
+
/**
|
|
10087
|
+
* Declared editability of a state slot — the generic edit seam's gate. Default
|
|
10088
|
+
* (absent) is NOT editable: a slot is op-only engine working memory unless the
|
|
10089
|
+
* modeler opens it. The stored form is `true` (editable by anyone within the
|
|
10090
|
+
* slot's scope window) or a GROQ predicate over the rendered scope (`$actor`,
|
|
10091
|
+
* `$can`, `$state`, `$assigned`), checked like an action filter to decide
|
|
10092
|
+
* who-may-edit. ADVISORY like every engine gate — it disables the inline field
|
|
10093
|
+
* and explains; real immutability needs a lake {@link Guard}.
|
|
10094
|
+
*/
|
|
10095
|
+
declare const StoredEditableSchema: v.UnionSchema<
|
|
10096
|
+
[
|
|
10097
|
+
v.LiteralSchema<true, undefined>,
|
|
10098
|
+
v.SchemaWithPipe<
|
|
10099
|
+
readonly [
|
|
10100
|
+
v.StringSchema<undefined>,
|
|
10101
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
10102
|
+
]
|
|
10103
|
+
>,
|
|
10104
|
+
],
|
|
10105
|
+
undefined
|
|
10106
|
+
>;
|
|
10107
|
+
|
|
9333
10108
|
declare const StoredOpSchema: v.VariantSchema<
|
|
9334
10109
|
"type",
|
|
9335
10110
|
[
|
|
@@ -10241,7 +11016,7 @@ declare const StoredStageSchema: v.StrictObjectSchema<
|
|
|
10241
11016
|
v.ArraySchema<
|
|
10242
11017
|
v.StrictObjectSchema<
|
|
10243
11018
|
{
|
|
10244
|
-
|
|
11019
|
+
type: v.PicklistSchema<
|
|
10245
11020
|
readonly [
|
|
10246
11021
|
"doc.ref",
|
|
10247
11022
|
"doc.refs",
|
|
@@ -10259,21 +11034,52 @@ declare const StoredStageSchema: v.StrictObjectSchema<
|
|
|
10259
11034
|
],
|
|
10260
11035
|
`Invalid option: expected one of ${string}`
|
|
10261
11036
|
>;
|
|
10262
|
-
|
|
11037
|
+
name: v.SchemaWithPipe<
|
|
10263
11038
|
readonly [
|
|
10264
11039
|
v.StringSchema<undefined>,
|
|
10265
11040
|
v.RegexAction<string, string>,
|
|
10266
11041
|
]
|
|
10267
11042
|
>;
|
|
10268
|
-
|
|
11043
|
+
title: v.OptionalSchema<
|
|
10269
11044
|
v.StringSchema<undefined>,
|
|
10270
11045
|
undefined
|
|
10271
11046
|
>;
|
|
10272
|
-
|
|
11047
|
+
description: v.OptionalSchema<
|
|
10273
11048
|
v.StringSchema<undefined>,
|
|
10274
11049
|
undefined
|
|
10275
11050
|
>;
|
|
10276
|
-
|
|
11051
|
+
/**
|
|
11052
|
+
* When true, the caller MUST supply this entry at start (via
|
|
11053
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
11054
|
+
* missing required entry throws rather than silently defaulting to
|
|
11055
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
11056
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
11057
|
+
*/
|
|
11058
|
+
required: v.OptionalSchema<
|
|
11059
|
+
v.BooleanSchema<undefined>,
|
|
11060
|
+
undefined
|
|
11061
|
+
>;
|
|
11062
|
+
source: v.GenericSchema<SourceInternal>;
|
|
11063
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
11064
|
+
editable: v.OptionalSchema<
|
|
11065
|
+
v.UnionSchema<
|
|
11066
|
+
[
|
|
11067
|
+
v.LiteralSchema<true, undefined>,
|
|
11068
|
+
v.SchemaWithPipe<
|
|
11069
|
+
readonly [
|
|
11070
|
+
v.StringSchema<undefined>,
|
|
11071
|
+
v.MinLengthAction<
|
|
11072
|
+
string,
|
|
11073
|
+
1,
|
|
11074
|
+
"must be a non-empty string"
|
|
11075
|
+
>,
|
|
11076
|
+
]
|
|
11077
|
+
>,
|
|
11078
|
+
],
|
|
11079
|
+
undefined
|
|
11080
|
+
>,
|
|
11081
|
+
undefined
|
|
11082
|
+
>;
|
|
10277
11083
|
},
|
|
10278
11084
|
undefined
|
|
10279
11085
|
>,
|
|
@@ -10684,7 +11490,7 @@ declare const StoredStageSchema: v.StrictObjectSchema<
|
|
|
10684
11490
|
v.ArraySchema<
|
|
10685
11491
|
v.StrictObjectSchema<
|
|
10686
11492
|
{
|
|
10687
|
-
|
|
11493
|
+
type: v.PicklistSchema<
|
|
10688
11494
|
readonly [
|
|
10689
11495
|
"doc.ref",
|
|
10690
11496
|
"doc.refs",
|
|
@@ -10702,21 +11508,43 @@ declare const StoredStageSchema: v.StrictObjectSchema<
|
|
|
10702
11508
|
],
|
|
10703
11509
|
`Invalid option: expected one of ${string}`
|
|
10704
11510
|
>;
|
|
10705
|
-
|
|
11511
|
+
name: v.SchemaWithPipe<
|
|
10706
11512
|
readonly [
|
|
10707
11513
|
v.StringSchema<undefined>,
|
|
10708
11514
|
v.RegexAction<string, string>,
|
|
10709
11515
|
]
|
|
10710
11516
|
>;
|
|
10711
|
-
|
|
10712
|
-
|
|
10713
|
-
|
|
10714
|
-
|
|
10715
|
-
|
|
10716
|
-
|
|
11517
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
11518
|
+
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
11519
|
+
/**
|
|
11520
|
+
* When true, the caller MUST supply this entry at start (via
|
|
11521
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
11522
|
+
* missing required entry throws rather than silently defaulting to
|
|
11523
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
11524
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
11525
|
+
*/
|
|
11526
|
+
required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
11527
|
+
source: v.GenericSchema<SourceInternal>;
|
|
11528
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
11529
|
+
editable: v.OptionalSchema<
|
|
11530
|
+
v.UnionSchema<
|
|
11531
|
+
[
|
|
11532
|
+
v.LiteralSchema<true, undefined>,
|
|
11533
|
+
v.SchemaWithPipe<
|
|
11534
|
+
readonly [
|
|
11535
|
+
v.StringSchema<undefined>,
|
|
11536
|
+
v.MinLengthAction<
|
|
11537
|
+
string,
|
|
11538
|
+
1,
|
|
11539
|
+
"must be a non-empty string"
|
|
11540
|
+
>,
|
|
11541
|
+
]
|
|
11542
|
+
>,
|
|
11543
|
+
],
|
|
11544
|
+
undefined
|
|
11545
|
+
>,
|
|
10717
11546
|
undefined
|
|
10718
11547
|
>;
|
|
10719
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
10720
11548
|
},
|
|
10721
11549
|
undefined
|
|
10722
11550
|
>,
|
|
@@ -10724,6 +11552,34 @@ declare const StoredStageSchema: v.StrictObjectSchema<
|
|
|
10724
11552
|
>,
|
|
10725
11553
|
undefined
|
|
10726
11554
|
>;
|
|
11555
|
+
/**
|
|
11556
|
+
* Tighten-only editability overrides for the time this stage holds, keyed
|
|
11557
|
+
* by an in-scope slot name. The slot's own `editable` is the ceiling; a
|
|
11558
|
+
* stage value is ANDed with it at runtime, so an override can only NARROW
|
|
11559
|
+
* (never open a slot the baseline left closed). An unlisted slot inherits
|
|
11560
|
+
* its baseline.
|
|
11561
|
+
*/
|
|
11562
|
+
editable: v.OptionalSchema<
|
|
11563
|
+
v.RecordSchema<
|
|
11564
|
+
v.SchemaWithPipe<
|
|
11565
|
+
readonly [v.StringSchema<undefined>, v.RegexAction<string, string>]
|
|
11566
|
+
>,
|
|
11567
|
+
v.UnionSchema<
|
|
11568
|
+
[
|
|
11569
|
+
v.LiteralSchema<true, undefined>,
|
|
11570
|
+
v.SchemaWithPipe<
|
|
11571
|
+
readonly [
|
|
11572
|
+
v.StringSchema<undefined>,
|
|
11573
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
11574
|
+
]
|
|
11575
|
+
>,
|
|
11576
|
+
],
|
|
11577
|
+
undefined
|
|
11578
|
+
>,
|
|
11579
|
+
undefined
|
|
11580
|
+
>,
|
|
11581
|
+
undefined
|
|
11582
|
+
>;
|
|
10727
11583
|
},
|
|
10728
11584
|
undefined
|
|
10729
11585
|
>;
|
|
@@ -11438,7 +12294,7 @@ declare const StoredTaskSchema: v.StrictObjectSchema<
|
|
|
11438
12294
|
v.ArraySchema<
|
|
11439
12295
|
v.StrictObjectSchema<
|
|
11440
12296
|
{
|
|
11441
|
-
|
|
12297
|
+
type: v.PicklistSchema<
|
|
11442
12298
|
readonly [
|
|
11443
12299
|
"doc.ref",
|
|
11444
12300
|
"doc.refs",
|
|
@@ -11456,21 +12312,43 @@ declare const StoredTaskSchema: v.StrictObjectSchema<
|
|
|
11456
12312
|
],
|
|
11457
12313
|
`Invalid option: expected one of ${string}`
|
|
11458
12314
|
>;
|
|
11459
|
-
|
|
12315
|
+
name: v.SchemaWithPipe<
|
|
11460
12316
|
readonly [
|
|
11461
12317
|
v.StringSchema<undefined>,
|
|
11462
12318
|
v.RegexAction<string, string>,
|
|
11463
12319
|
]
|
|
11464
12320
|
>;
|
|
11465
|
-
|
|
11466
|
-
|
|
11467
|
-
|
|
11468
|
-
|
|
11469
|
-
|
|
11470
|
-
|
|
12321
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
12322
|
+
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
12323
|
+
/**
|
|
12324
|
+
* When true, the caller MUST supply this entry at start (via
|
|
12325
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
12326
|
+
* missing required entry throws rather than silently defaulting to
|
|
12327
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
12328
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
12329
|
+
*/
|
|
12330
|
+
required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
12331
|
+
source: v.GenericSchema<SourceInternal>;
|
|
12332
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
12333
|
+
editable: v.OptionalSchema<
|
|
12334
|
+
v.UnionSchema<
|
|
12335
|
+
[
|
|
12336
|
+
v.LiteralSchema<true, undefined>,
|
|
12337
|
+
v.SchemaWithPipe<
|
|
12338
|
+
readonly [
|
|
12339
|
+
v.StringSchema<undefined>,
|
|
12340
|
+
v.MinLengthAction<
|
|
12341
|
+
string,
|
|
12342
|
+
1,
|
|
12343
|
+
"must be a non-empty string"
|
|
12344
|
+
>,
|
|
12345
|
+
]
|
|
12346
|
+
>,
|
|
12347
|
+
],
|
|
12348
|
+
undefined
|
|
12349
|
+
>,
|
|
11471
12350
|
undefined
|
|
11472
12351
|
>;
|
|
11473
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
11474
12352
|
},
|
|
11475
12353
|
undefined
|
|
11476
12354
|
>,
|
|
@@ -12244,6 +13122,22 @@ export declare const workflow: {
|
|
|
12244
13122
|
* timer firings. External signals never bypass this.
|
|
12245
13123
|
*/
|
|
12246
13124
|
fireAction: (args: Clocked<FireActionArgs>) => Promise<DispatchResult>;
|
|
13125
|
+
/**
|
|
13126
|
+
* Edit a declared-editable state slot directly — reassign, reschedule,
|
|
13127
|
+
* claim-by-hand, append to a running log — through the generic edit seam,
|
|
13128
|
+
* instead of a bespoke action per field. Soft-gates on the slot's declared
|
|
13129
|
+
* editability (the same projection a UI renders), applies the edit as a
|
|
13130
|
+
* `state.*` op (so provenance + history are stamped by the op path),
|
|
13131
|
+
* refreshes the stage's guards, then cascades — an edit to a value a
|
|
13132
|
+
* transition reads can and should move the instance. Advisory like every
|
|
13133
|
+
* engine gate; the lake ACL + guards are the only hard locks.
|
|
13134
|
+
*
|
|
13135
|
+
* Each call is a discrete COMMIT (a history entry, a guard refresh, a
|
|
13136
|
+
* cascade, an `ifRevisionId` write), not a draft patch — so an inline-field
|
|
13137
|
+
* UI must bind it to a deliberate boundary (blur / Enter / Save / debounce),
|
|
13138
|
+
* never an `onChange` per keystroke.
|
|
13139
|
+
*/
|
|
13140
|
+
editState: (args: Clocked<EditStateArgs>) => Promise<DispatchResult>;
|
|
12247
13141
|
/**
|
|
12248
13142
|
* Report a queued effect's outcome. Drains it from `pendingEffects`,
|
|
12249
13143
|
* appends an `effectHistory` entry, and (if `outputs` are supplied
|
|
@@ -12444,6 +13338,8 @@ export declare const WORKFLOW_DEFINITION_TYPE = "sanity.workflow.definition";
|
|
|
12444
13338
|
*/
|
|
12445
13339
|
export declare const WORKFLOW_INSTANCE_TYPE = "sanity.workflow.instance";
|
|
12446
13340
|
|
|
13341
|
+
declare const WORKFLOW_ROLES: readonly ["workflow", "child"];
|
|
13342
|
+
|
|
12447
13343
|
/**
|
|
12448
13344
|
* The engine's view of "who am I, what can I do?". `actor` is who
|
|
12449
13345
|
* the engine stamps onto history / `completedBy` / `Source.actor`.
|
|
@@ -12604,6 +13500,22 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
12604
13500
|
]
|
|
12605
13501
|
>;
|
|
12606
13502
|
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
13503
|
+
/**
|
|
13504
|
+
* Whether a human may start this workflow standalone. `'child'` marks a
|
|
13505
|
+
* spawn-only definition — instantiated by a parent via `task.subworkflows`,
|
|
13506
|
+
* never started cold from a picker. Omitted ⇒ `'workflow'` (startable).
|
|
13507
|
+
* Advisory: consumers filter their start pickers on it (see
|
|
13508
|
+
* {@link isStartableDefinition}); the engine does NOT refuse a
|
|
13509
|
+
* `startInstance` on a `'child'` def — load-bearing `required` state is the
|
|
13510
|
+
* runtime backstop.
|
|
13511
|
+
*/
|
|
13512
|
+
role: v.OptionalSchema<
|
|
13513
|
+
v.PicklistSchema<
|
|
13514
|
+
readonly ["workflow", "child"],
|
|
13515
|
+
`Invalid option: expected one of ${string}`
|
|
13516
|
+
>,
|
|
13517
|
+
undefined
|
|
13518
|
+
>;
|
|
12607
13519
|
/** Reference field: named for the target, holds the stage's `name`. */
|
|
12608
13520
|
initialStage: v.SchemaWithPipe<
|
|
12609
13521
|
readonly [
|
|
@@ -12616,7 +13528,7 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
12616
13528
|
v.ArraySchema<
|
|
12617
13529
|
v.StrictObjectSchema<
|
|
12618
13530
|
{
|
|
12619
|
-
|
|
13531
|
+
type: v.PicklistSchema<
|
|
12620
13532
|
readonly [
|
|
12621
13533
|
"doc.ref",
|
|
12622
13534
|
"doc.refs",
|
|
@@ -12634,21 +13546,43 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
12634
13546
|
],
|
|
12635
13547
|
`Invalid option: expected one of ${string}`
|
|
12636
13548
|
>;
|
|
12637
|
-
|
|
13549
|
+
name: v.SchemaWithPipe<
|
|
12638
13550
|
readonly [
|
|
12639
13551
|
v.StringSchema<undefined>,
|
|
12640
13552
|
v.RegexAction<string, string>,
|
|
12641
13553
|
]
|
|
12642
13554
|
>;
|
|
12643
|
-
|
|
12644
|
-
|
|
12645
|
-
|
|
12646
|
-
|
|
12647
|
-
|
|
12648
|
-
|
|
13555
|
+
title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
13556
|
+
description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
13557
|
+
/**
|
|
13558
|
+
* When true, the caller MUST supply this entry at start (via
|
|
13559
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
13560
|
+
* missing required entry throws rather than silently defaulting to
|
|
13561
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
13562
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
13563
|
+
*/
|
|
13564
|
+
required: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
13565
|
+
source: v.GenericSchema<SourceInternal>;
|
|
13566
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
13567
|
+
editable: v.OptionalSchema<
|
|
13568
|
+
v.UnionSchema<
|
|
13569
|
+
[
|
|
13570
|
+
v.LiteralSchema<true, undefined>,
|
|
13571
|
+
v.SchemaWithPipe<
|
|
13572
|
+
readonly [
|
|
13573
|
+
v.StringSchema<undefined>,
|
|
13574
|
+
v.MinLengthAction<
|
|
13575
|
+
string,
|
|
13576
|
+
1,
|
|
13577
|
+
"must be a non-empty string"
|
|
13578
|
+
>,
|
|
13579
|
+
]
|
|
13580
|
+
>,
|
|
13581
|
+
],
|
|
13582
|
+
undefined
|
|
13583
|
+
>,
|
|
12649
13584
|
undefined
|
|
12650
13585
|
>;
|
|
12651
|
-
readonly source: v.GenericSchema<SourceInternal>;
|
|
12652
13586
|
},
|
|
12653
13587
|
undefined
|
|
12654
13588
|
>,
|
|
@@ -13500,7 +14434,7 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
13500
14434
|
v.ArraySchema<
|
|
13501
14435
|
v.StrictObjectSchema<
|
|
13502
14436
|
{
|
|
13503
|
-
|
|
14437
|
+
type: v.PicklistSchema<
|
|
13504
14438
|
readonly [
|
|
13505
14439
|
"doc.ref",
|
|
13506
14440
|
"doc.refs",
|
|
@@ -13518,21 +14452,52 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
13518
14452
|
],
|
|
13519
14453
|
`Invalid option: expected one of ${string}`
|
|
13520
14454
|
>;
|
|
13521
|
-
|
|
14455
|
+
name: v.SchemaWithPipe<
|
|
13522
14456
|
readonly [
|
|
13523
14457
|
v.StringSchema<undefined>,
|
|
13524
14458
|
v.RegexAction<string, string>,
|
|
13525
14459
|
]
|
|
13526
14460
|
>;
|
|
13527
|
-
|
|
14461
|
+
title: v.OptionalSchema<
|
|
13528
14462
|
v.StringSchema<undefined>,
|
|
13529
14463
|
undefined
|
|
13530
14464
|
>;
|
|
13531
|
-
|
|
14465
|
+
description: v.OptionalSchema<
|
|
13532
14466
|
v.StringSchema<undefined>,
|
|
13533
14467
|
undefined
|
|
13534
14468
|
>;
|
|
13535
|
-
|
|
14469
|
+
/**
|
|
14470
|
+
* When true, the caller MUST supply this entry at start (via
|
|
14471
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
14472
|
+
* missing required entry throws rather than silently defaulting to
|
|
14473
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
14474
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
14475
|
+
*/
|
|
14476
|
+
required: v.OptionalSchema<
|
|
14477
|
+
v.BooleanSchema<undefined>,
|
|
14478
|
+
undefined
|
|
14479
|
+
>;
|
|
14480
|
+
source: v.GenericSchema<SourceInternal>;
|
|
14481
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
14482
|
+
editable: v.OptionalSchema<
|
|
14483
|
+
v.UnionSchema<
|
|
14484
|
+
[
|
|
14485
|
+
v.LiteralSchema<true, undefined>,
|
|
14486
|
+
v.SchemaWithPipe<
|
|
14487
|
+
readonly [
|
|
14488
|
+
v.StringSchema<undefined>,
|
|
14489
|
+
v.MinLengthAction<
|
|
14490
|
+
string,
|
|
14491
|
+
1,
|
|
14492
|
+
"must be a non-empty string"
|
|
14493
|
+
>,
|
|
14494
|
+
]
|
|
14495
|
+
>,
|
|
14496
|
+
],
|
|
14497
|
+
undefined
|
|
14498
|
+
>,
|
|
14499
|
+
undefined
|
|
14500
|
+
>;
|
|
13536
14501
|
},
|
|
13537
14502
|
undefined
|
|
13538
14503
|
>,
|
|
@@ -13976,7 +14941,7 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
13976
14941
|
v.ArraySchema<
|
|
13977
14942
|
v.StrictObjectSchema<
|
|
13978
14943
|
{
|
|
13979
|
-
|
|
14944
|
+
type: v.PicklistSchema<
|
|
13980
14945
|
readonly [
|
|
13981
14946
|
"doc.ref",
|
|
13982
14947
|
"doc.refs",
|
|
@@ -13994,21 +14959,52 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
13994
14959
|
],
|
|
13995
14960
|
`Invalid option: expected one of ${string}`
|
|
13996
14961
|
>;
|
|
13997
|
-
|
|
14962
|
+
name: v.SchemaWithPipe<
|
|
13998
14963
|
readonly [
|
|
13999
14964
|
v.StringSchema<undefined>,
|
|
14000
14965
|
v.RegexAction<string, string>,
|
|
14001
14966
|
]
|
|
14002
14967
|
>;
|
|
14003
|
-
|
|
14968
|
+
title: v.OptionalSchema<
|
|
14004
14969
|
v.StringSchema<undefined>,
|
|
14005
14970
|
undefined
|
|
14006
14971
|
>;
|
|
14007
|
-
|
|
14972
|
+
description: v.OptionalSchema<
|
|
14008
14973
|
v.StringSchema<undefined>,
|
|
14009
14974
|
undefined
|
|
14010
14975
|
>;
|
|
14011
|
-
|
|
14976
|
+
/**
|
|
14977
|
+
* When true, the caller MUST supply this entry at start (via
|
|
14978
|
+
* `initialState`) or spawn (via the parent's `subworkflows.with`). A
|
|
14979
|
+
* missing required entry throws rather than silently defaulting to
|
|
14980
|
+
* `null`/`[]` — the same fail-fast an action's `required` param gets.
|
|
14981
|
+
* Valid only on a workflow-scope `init`-sourced entry (deploy invariant).
|
|
14982
|
+
*/
|
|
14983
|
+
required: v.OptionalSchema<
|
|
14984
|
+
v.BooleanSchema<undefined>,
|
|
14985
|
+
undefined
|
|
14986
|
+
>;
|
|
14987
|
+
source: v.GenericSchema<SourceInternal>;
|
|
14988
|
+
/** Who-may-edit this slot via the edit seam — see {@link StoredEditableSchema}. */
|
|
14989
|
+
editable: v.OptionalSchema<
|
|
14990
|
+
v.UnionSchema<
|
|
14991
|
+
[
|
|
14992
|
+
v.LiteralSchema<true, undefined>,
|
|
14993
|
+
v.SchemaWithPipe<
|
|
14994
|
+
readonly [
|
|
14995
|
+
v.StringSchema<undefined>,
|
|
14996
|
+
v.MinLengthAction<
|
|
14997
|
+
string,
|
|
14998
|
+
1,
|
|
14999
|
+
"must be a non-empty string"
|
|
15000
|
+
>,
|
|
15001
|
+
]
|
|
15002
|
+
>,
|
|
15003
|
+
],
|
|
15004
|
+
undefined
|
|
15005
|
+
>,
|
|
15006
|
+
undefined
|
|
15007
|
+
>;
|
|
14012
15008
|
},
|
|
14013
15009
|
undefined
|
|
14014
15010
|
>,
|
|
@@ -14016,6 +15012,41 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
14016
15012
|
>,
|
|
14017
15013
|
undefined
|
|
14018
15014
|
>;
|
|
15015
|
+
/**
|
|
15016
|
+
* Tighten-only editability overrides for the time this stage holds, keyed
|
|
15017
|
+
* by an in-scope slot name. The slot's own `editable` is the ceiling; a
|
|
15018
|
+
* stage value is ANDed with it at runtime, so an override can only NARROW
|
|
15019
|
+
* (never open a slot the baseline left closed). An unlisted slot inherits
|
|
15020
|
+
* its baseline.
|
|
15021
|
+
*/
|
|
15022
|
+
editable: v.OptionalSchema<
|
|
15023
|
+
v.RecordSchema<
|
|
15024
|
+
v.SchemaWithPipe<
|
|
15025
|
+
readonly [
|
|
15026
|
+
v.StringSchema<undefined>,
|
|
15027
|
+
v.RegexAction<string, string>,
|
|
15028
|
+
]
|
|
15029
|
+
>,
|
|
15030
|
+
v.UnionSchema<
|
|
15031
|
+
[
|
|
15032
|
+
v.LiteralSchema<true, undefined>,
|
|
15033
|
+
v.SchemaWithPipe<
|
|
15034
|
+
readonly [
|
|
15035
|
+
v.StringSchema<undefined>,
|
|
15036
|
+
v.MinLengthAction<
|
|
15037
|
+
string,
|
|
15038
|
+
1,
|
|
15039
|
+
"must be a non-empty string"
|
|
15040
|
+
>,
|
|
15041
|
+
]
|
|
15042
|
+
>,
|
|
15043
|
+
],
|
|
15044
|
+
undefined
|
|
15045
|
+
>,
|
|
15046
|
+
undefined
|
|
15047
|
+
>,
|
|
15048
|
+
undefined
|
|
15049
|
+
>;
|
|
14019
15050
|
},
|
|
14020
15051
|
undefined
|
|
14021
15052
|
>,
|
|
@@ -14246,7 +15277,9 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
14246
15277
|
name: string;
|
|
14247
15278
|
title?: string | undefined;
|
|
14248
15279
|
description?: string | undefined;
|
|
15280
|
+
required?: boolean | undefined;
|
|
14249
15281
|
source: SourceInternal;
|
|
15282
|
+
editable?: string | true | undefined;
|
|
14250
15283
|
}[]
|
|
14251
15284
|
| undefined;
|
|
14252
15285
|
}[]
|
|
@@ -14365,9 +15398,16 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
14365
15398
|
name: string;
|
|
14366
15399
|
title?: string | undefined;
|
|
14367
15400
|
description?: string | undefined;
|
|
15401
|
+
required?: boolean | undefined;
|
|
14368
15402
|
source: SourceInternal;
|
|
15403
|
+
editable?: string | true | undefined;
|
|
14369
15404
|
}[]
|
|
14370
15405
|
| undefined;
|
|
15406
|
+
editable?:
|
|
15407
|
+
| {
|
|
15408
|
+
[x: string]: string | true;
|
|
15409
|
+
}
|
|
15410
|
+
| undefined;
|
|
14371
15411
|
}[],
|
|
14372
15412
|
1,
|
|
14373
15413
|
"must declare at least one stage"
|
|
@@ -14394,6 +15434,37 @@ declare const WorkflowDefinitionSchema: v.StrictObjectSchema<
|
|
|
14394
15434
|
>,
|
|
14395
15435
|
undefined
|
|
14396
15436
|
>;
|
|
15437
|
+
/** Role aliasing for this definition — see {@link RoleAliasesSchema}. */
|
|
15438
|
+
roleAliases: v.OptionalSchema<
|
|
15439
|
+
v.RecordSchema<
|
|
15440
|
+
v.SchemaWithPipe<
|
|
15441
|
+
readonly [
|
|
15442
|
+
v.StringSchema<undefined>,
|
|
15443
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
15444
|
+
]
|
|
15445
|
+
>,
|
|
15446
|
+
v.SchemaWithPipe<
|
|
15447
|
+
readonly [
|
|
15448
|
+
v.ArraySchema<
|
|
15449
|
+
v.SchemaWithPipe<
|
|
15450
|
+
readonly [
|
|
15451
|
+
v.StringSchema<undefined>,
|
|
15452
|
+
v.MinLengthAction<string, 1, "must be a non-empty string">,
|
|
15453
|
+
]
|
|
15454
|
+
>,
|
|
15455
|
+
undefined
|
|
15456
|
+
>,
|
|
15457
|
+
v.MinLengthAction<
|
|
15458
|
+
string[],
|
|
15459
|
+
1,
|
|
15460
|
+
"a role alias must list at least one fulfilling role"
|
|
15461
|
+
>,
|
|
15462
|
+
]
|
|
15463
|
+
>,
|
|
15464
|
+
undefined
|
|
15465
|
+
>,
|
|
15466
|
+
undefined
|
|
15467
|
+
>;
|
|
14397
15468
|
},
|
|
14398
15469
|
undefined
|
|
14399
15470
|
>;
|
|
@@ -14407,6 +15478,13 @@ export declare interface WorkflowEvaluation {
|
|
|
14407
15478
|
pendingOnYou: TaskEvaluation[];
|
|
14408
15479
|
/** True if at least one action on any active task is allowed. */
|
|
14409
15480
|
canInteract: boolean;
|
|
15481
|
+
/**
|
|
15482
|
+
* Declared-editable slots in the current scope (workflow + current stage +
|
|
15483
|
+
* its tasks), each with this actor's edit verdict and the current value's
|
|
15484
|
+
* provenance. The reactive edit-seam surface; empty when the workflow
|
|
15485
|
+
* declares no editable slots.
|
|
15486
|
+
*/
|
|
15487
|
+
editableSlots: EditableSlotEvaluation[];
|
|
14410
15488
|
}
|
|
14411
15489
|
|
|
14412
15490
|
export declare interface WorkflowFetchOptions {
|
|
@@ -14561,13 +15639,18 @@ export declare type WorkflowResource =
|
|
|
14561
15639
|
id: string;
|
|
14562
15640
|
};
|
|
14563
15641
|
|
|
15642
|
+
/** A definition's lifecycle role. `'child'` is spawn-only — see {@link isStartableDefinition}. */
|
|
15643
|
+
export declare type WorkflowRole = (typeof WORKFLOW_ROLES)[number];
|
|
15644
|
+
|
|
14564
15645
|
/**
|
|
14565
15646
|
* Thrown when a guard deploy fails *after* its state move committed and the
|
|
14566
|
-
* engine could not
|
|
14567
|
-
*
|
|
14568
|
-
*
|
|
14569
|
-
*
|
|
14570
|
-
*
|
|
15647
|
+
* engine could not cleanly undo the result — any of: the rollback write itself
|
|
15648
|
+
* failed; the move created sibling docs (spawn) that a parent-only rollback
|
|
15649
|
+
* cannot undo; or a multi-guard deploy partially applied, so even a clean state
|
|
15650
|
+
* rollback leaves the earlier guards orphaned ({@link PartialGuardDeployError}).
|
|
15651
|
+
* The workflow's persisted state and its deployed guards are now divergent and
|
|
15652
|
+
* need manual reconciliation; the engine screams rather than leaving the
|
|
15653
|
+
* inconsistency silent.
|
|
14571
15654
|
*/
|
|
14572
15655
|
export declare class WorkflowStateDivergedError extends Error {
|
|
14573
15656
|
readonly instanceId: string;
|