grafast 0.1.1-beta.4 → 0.1.1-beta.5

package/dist/bucket.d.ts

@@ -1,90 +1,2 @@
-import type { LayerPlan } from "./engine/LayerPlan";
-import type { MetaByMetaKey } from "./engine/OperationPlan";
-import type { ExecutionEventEmitter } from "./interfaces.js";
-/**
- * @internal
- */
-export interface RequestTools {
-    /** The `timeSource.now()` at which the request started executing */
-    startTime: number;
-    /** The `timeSource.now()` at which the request should stop executing (if a timeout was configured) */
-    stopTime: number | null;
-    readonly eventEmitter: ExecutionEventEmitter | undefined;
-    /**
-     * If we're running inside GraphQL then we should not serialize scalars,
-     * otherwise we'll face the double-serialization problem.
-     */
-    insideGraphQL: false;
-}
-/**
- * A "bucket" is where the results from plans are stored so that other plans
- * can retrieve them, it may take on different forms depending on the mode of
- * execution. A "LayerPlan" is used to both identify the bucket and to specify
- * why it exists and how it behaves.
- *
- * Every `ExecutableStep` belongs to exactly one LayerPlan (and thus bucket),
- * specified by `plan.layerPlan`.
- *
- * @internal
- */
-export interface Bucket {
-    /**
-     * The LayerPlan definition this bucket adheres to
-     */
-    layerPlan: LayerPlan;
-    /**
-     * How many entries are there in the bucket?
-     */
-    size: number;
-    /**
-     * The polymorphic path through which each of the entries (respectively) has
-     * travelled. This influences the steps that will be executed using the
-     * related inputs.
-     */
-    polymorphicPathList: readonly (string | null)[];
-    /**
-     * These are the iterators the bucket (or its descendents, without crossing a
-     * stream/defer boundary) have created (if any). Each of these must either be
-     * processed via `processRoot`, or must be manually released (via
-     * `releaseUnusedIterators`) otherwise a memory leak could occur.
-     */
-    iterators: Array<Set<AsyncIterator<any> | Iterator<any>>>;
-    /**
-     * `metaByMetaKey` belongs to the bucket rather than the request context
-     * because mutations and subscriptions shouldn't re-use caches.
-     *
-     * TODO: `inheritMeta: boolean`?
-     */
-    metaByMetaKey: MetaByMetaKey;
-    /**
-     * Every entry in the store is a list with the same length as the bucket has
-     * `size`.
-     *
-     * The entry for '-1' is the request indexes, so we can associate the results
-     * back to the request that triggered them.
-     */
-    store: Map<number, any[]>;
-    /**
-     * Set this true when the bucket is fully executed.
-     *
-     * Initialize it to false.
-     */
-    isComplete: boolean;
-    /**
-     * If an error occurred at any stage we need to drop down to more careful
-     * (and slower) handling.
-     *
-     * Initialize it to false.
-     */
-    hasErrors: boolean;
-    /**
-     * The child buckets of this bucket.
-     */
-    children: {
-        [layerPlanId: number]: {
-            bucket: Bucket;
-            map: Map<number, number | number[]>;
-        };
-    };
-}
+export {};
 //# sourceMappingURL=bucket.d.ts.map

package/dist/dev.d.ts

@@ -1,6 +1,2 @@
-/**
- * @internal
- */
-export declare const isDev: boolean;
 export declare function noop(): void;
 //# sourceMappingURL=dev.d.ts.map

package/dist/engine/LayerPlan.d.ts

@@ -1,5 +1,5 @@
 import type { Bucket } from "../bucket.js";
-import type { ExecutableStep, ModifierStep, UnbatchedExecutableStep } from "../step";
+import type { ExecutableStep } from "../step";
 import type { OperationPlan } from "./OperationPlan";
 /** Non-branching, non-deferred */
 export interface LayerPlanReasonRoot {
@@ -71,43 +71,6 @@ export type HasParent<A extends LayerPlanReason> = A extends any ? A extends {
     parentStep: ExecutableStep;
 } ? A : never : never;
 export type LayerPlanReasonsWithParentStep = HasParent<LayerPlanReason>;
-/** @internal */
-export interface LayerPlanPhase {
-    /**
-     * If true, we should check before the layer plan executes to see if the
-     * execution has already timed out.
-     *
-     * @see {@link RequestTools.stopTime}
-     */
-    checkTimeout: boolean;
-    /**
-     * A list of steps that can be ran in parallel at this point, since all
-     * their previous dependencies have already been satisfied.
-     */
-    normalSteps: Array<{
-        step: ExecutableStep;
-    }> | undefined;
-    /**
-     * A list of 'isSyncAndSafe' steps with unbatchedExecute methods that can be
-     * ran once the `normalSteps` have completed; they must only depend on steps
-     * that have already been executed before them (including previous
-     * unbatchedSyncAndSafeSteps in the same list).
-     */
-    unbatchedSyncAndSafeSteps: Array<{
-        step: UnbatchedExecutableStep;
-        /**
-         * Store the result of the step here if you want - useful to avoid lookups
-         * and when there's no storage. HIGHLY VOLATILE, will not survive a tick!
-         */
-        scratchpad: any;
-    }> | undefined;
-    /**
-     * Optimization - a digest of all steps in normalSteps and unbatchedSyncAndSafeSteps
-     *
-     * @internal
-     */
-    _allSteps: ExecutableStep[];
-}
 /**
  * A LayerPlan represents (via "reason") either the root (root), when something
  * happens at a later time (mutationField, defer), when plurality changes
@@ -138,58 +101,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     parentLayerPlan: LayerPlan | null;
     readonly reason: TReason;
     id: number;
-    /**
-     * Every layer plan has a "root step" that shapes the value the layer
-     * returns. Note that this step may be dependent on other steps included in
-     * the LayerPlan, or could be provided externally.
-     *
-     * The root step is different for different layer step reasons:
-     *
-     * - root: the `operationPlan.rootValue`
-     * - listItem: the `__ItemStep`
-     * - stream: also the `__ItemStep`
-     * - subscription: also the `__ItemStep`
-     * - mutationField: the result plan of the mutation field
-     * - defer: the parent layer's rootStep (defer always results in an object, unless an error occurs)
-     * - polymorphic: the plan for the particular type
-     * - subroutine: the result (returned) plan of the subroutine
-     *
-     * @internal
-     */
-    readonly rootStep: ExecutableStep | null;
-    /**
-     * Which plans the results for which are available in a parent bucket need to
-     * be "copied across" to this bucket because plans in this bucket still
-     * reference them?
-     *
-     * @internal
-     */
-    copyStepIds: number[];
-    /** @internal */
-    children: LayerPlan[];
-    /** @internal */
-    steps: ExecutableStep[];
-    /** @internal */
-    pendingSteps: ExecutableStep[];
-    /**
-     * Describes the order in which the steps within this LayerPlan are executed.
-     *
-     * Special attention must be paid to steps that have side effects.
-     *
-     * @internal
-     */
-    phases: Array<LayerPlanPhase>;
-    /**
-     * The list of layerPlans that steps added to this LayerPlan may depend upon.
-     * Note this includes self, so it has one more entry than `depth`.
-     *
-     * ```
-     * this.ancestry[this.depth] === this;
-     * ```
-     *
-     * @internal
-     */
-    ancestry: LayerPlan[];
     /** How "deep" this layer plan is (how many ancestors it has). The root layer plan has a depth of 0. */
     depth: number;
     /** The depth at which a "defer boundary" occurs (OperationPlan.getPeers cannot pass a defer boundary), or 0. */
@@ -203,12 +114,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     toString(): string;
     print(depth?: number): string;
     setRootStep($root: ExecutableStep): void;
-    /** @internal Use plan.getStep(id) instead. */
-    getStep(id: number, requestingStep: ExecutableStep): ExecutableStep;
-    /** @internal */
-    _addStep(step: ExecutableStep): number;
-    /** @internal */
-    _addModifierStep(step: ModifierStep<any>): string;
     finalize(): void;
     newBucket(parentBucket: Bucket): Bucket | null;
 }

package/dist/engine/OperationPlan.d.ts

@@ -1,16 +1,14 @@
 import type { FragmentDefinitionNode, GraphQLFieldMap, GraphQLObjectType, GraphQLSchema, GraphQLUnionType, OperationDefinitionNode } from "graphql";
-import type { Constraint } from "../constraints.js";
 import type { SelectionSetDigest } from "../graphqlCollectFields.js";
-import type { GrafastPlanJSON, ModifierStep } from "../index.js";
-import { __TrackedValueStep, __ValueStep, ExecutableStep } from "../index.js";
+import type { GrafastPlanJSON } from "../index.js";
+import { ExecutableStep } from "../index.js";
 import { $$timeout, $$ts } from "../interfaces.js";
 import type { LayerPlanReasonSubroutine } from "./LayerPlan.js";
 import { LayerPlan } from "./LayerPlan.js";
 import { OutputPlan } from "./OutputPlan.js";
-import { StepTracker } from "./StepTracker.js";
 export declare const POLYMORPHIC_ROOT_PATH: null;
 export declare const POLYMORPHIC_ROOT_PATHS: ReadonlySet<string> | null;
-/** @internal */
+/** Beware: the list of phases may change over time... @experimental */
 export type OperationPlanPhase = "init" | "plan" | "validate" | "optimize" | "finalize" | "ready";
 export interface MetaByMetaKey {
     [metaKey: string | number | symbol]: Record<string, any>;
@@ -49,62 +47,17 @@ export declare class OperationPlan {
      * 7. ready
      *
      * Once in 'ready' state we can execute the plan.
-     *
-     * @internal
      */
     phase: OperationPlanPhase;
     /**
      * Gets updated as we work our way through the plan, useful for making errors more helpful.
      */
     loc: string[] | null;
-    /** @internal */
-    rootLayerPlan: LayerPlan;
-    /**
-     * Assigned during OperationPlan.planOperation(), guaranteed to exist after
-     * initialization.
-     *
-     * @internal
-     */
-    rootOutputPlan: OutputPlan;
     private modifierStepCount;
     private modifierDepthCount;
     private modifierSteps;
-    /** @internal */
-    readonly stepTracker: StepTracker;
     private maxDeduplicatedStepId;
     private maxValidatedStepId;
-    /** Constraints based on evaluating variables. @internal */
-    readonly variableValuesConstraints: Constraint[];
-    /** Stores the actual variableValues. @internal */
-    readonly variableValuesStep: __ValueStep<{
-        [key: string]: any;
-    }>;
-    /** A step for accessing variableValues in a tracked manner (allowing eval). @internal */
-    readonly trackedVariableValuesStep: __TrackedValueStep<{
-        [key: string]: any;
-    }>;
-    /** Constraints based on evaluating context. @internal */
-    readonly contextConstraints: Constraint[];
-    /** Stores the actual value of the context. @internal */
-    readonly contextStep: __ValueStep<Grafast.Context>;
-    /** Allows accessing context in a tracked manner (allowing eval). @internal */
-    readonly trackedContextStep: __TrackedValueStep<{
-        [key: string]: any;
-    }>;
-    /** Constraints based on evaluating rootValue. @internal */
-    readonly rootValueConstraints: Constraint[];
-    /** Stores the actual value of rootValue. @internal */
-    readonly rootValueStep: __ValueStep<any>;
-    /** Allows accessing rootValue in a tracked manner (allowing eval). @internal */
-    readonly trackedRootValueStep: __TrackedValueStep<any>;
-    /** @internal */
-    makeMetaByMetaKey: () => MetaByMetaKey;
-    /**
-     * @internal
-     */
-    readonly itemStepIdByListStepId: {
-        [listStepId: number]: number | undefined;
-    };
     /**
      * If true, then this operation doesn't use (custom) resolvers.
      */
@@ -123,35 +76,6 @@ export declare class OperationPlan {
     }, rootValue: any, planningTimeout: number | null);
     private lap;
     private checkTimeout;
-    /**
-     * Called by the LayerPlan's constructor when it wants to get a new id to use.
-     *
-     * @internal
-     */
-    addLayerPlan(layerPlan: LayerPlan): number;
-    /**
-     * Adds a plan to the known steps and returns the number to use as the plan
-     * id. ONLY to be used from Step, user code should never call this directly.
-     *
-     * @internal
-     */
-    _addStep(plan: ExecutableStep): number;
-    /**
-     * Adds a plan to the known steps and returns the number to use as the plan
-     * id. ONLY to be used from Step, user code should never call this directly.
-     *
-     * @internal
-     */
-    _addModifierStep(step: ModifierStep<any>): string;
-    /** @internal Use plan.getStep(id) instead. */
-    getStep: (id: number, requestingStep: ExecutableStep) => ExecutableStep;
-    /**
-     * Get a plan without specifying who requested it; this disables all the
-     * caller checks. Only intended to be called from internal code.
-     *
-     * @internal
-     */
-    dangerouslyGetStep(id: number): ExecutableStep;
     private planOperation;
     /**
      * Plans a GraphQL query operation.
@@ -204,13 +128,6 @@ export declare class OperationPlan {
     private validateSteps;
     private replaceStep;
     private processStep;
-    /**
-     * Process the given steps, either dependencies first (root to leaf) or
-     * dependents first (leaves to root).
-     *
-     * @internal
-     */
-    processSteps(actionDescription: string, order: "dependents-first" | "dependencies-first", isReadonly: boolean, callback: (plan: ExecutableStep) => ExecutableStep): void;
     /**
      * Peers are steps of the same type (but not the same step!) that are in
      * compatible layers and have the same dependencies. Peers must not have side
@@ -268,12 +185,6 @@ export declare class OperationPlan {
     private walkOutputPlans;
     generatePlanJSON(): GrafastPlanJSON;
     finishSubroutine(subroutineStep: ExecutableStep, layerPlan: LayerPlan<LayerPlanReasonSubroutine>): void;
-    /**
-     * HIGHLY EXPERIMENTAL!
-     *
-     * @internal
-     */
-    deleteLayerPlan(layerPlan: LayerPlan): void;
     getStepsByMetaKey(metaKey: string | number | symbol): ExecutableStep[];
     getStepsByStepClass<TClass extends ExecutableStep>(klass: {
         new (...args: any[]): TClass;

package/dist/engine/OperationPlan.js

@@ -83,8 +83,6 @@ class OperationPlan {
          * 7. ready
          *
          * Once in 'ready' state we can execute the plan.
-         *
-         * @internal
          */
         this.phase = "init";
         /**
@@ -1269,7 +1267,7 @@ class OperationPlan {
         }
         else {
             // used for: hoist
-            for (const $processFirst of step.dependencies) {
+            for (const $processFirst of (0, utils_js_1.sudo)(step).dependencies) {
                 if (!processed.has($processFirst)) {
                     this.processStep(actionDescription, order, isReadonly, callback, processed, $processFirst);
                 }
@@ -1350,7 +1348,7 @@ class OperationPlan {
         if (step.hasSideEffects) {
             return EMPTY_ARRAY;
         }
-        const { dependencies: deps, layerPlan: layerPlan, constructor: stepConstructor, } = step;
+        const { dependencies: deps, layerPlan: layerPlan, constructor: stepConstructor, } = (0, utils_js_1.sudo)(step);
         const dependencyCount = deps.length;
         if (dependencyCount === 0) {
             let allPeers = null;
@@ -1388,7 +1386,7 @@ class OperationPlan {
                     !possiblyPeer.hasSideEffects &&
                     possiblyPeer.constructor === stepConstructor &&
                     peerLayerPlan.depth >= minDepth &&
-                    possiblyPeer.dependencies.length === dependencyCount &&
+                    (0, utils_js_1.sudo)(possiblyPeer).dependencies.length === dependencyCount &&
                     peerLayerPlan === ancestry[peerLayerPlan.depth]) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
@@ -1430,7 +1428,7 @@ class OperationPlan {
                             peerDependencyIndex === dependencyIndex &&
                             !possiblyPeer.hasSideEffects &&
                             possiblyPeer.constructor === stepConstructor &&
-                            possiblyPeer.dependencies.length === dependencyCount &&
+                            (0, utils_js_1.sudo)(possiblyPeer).dependencies.length === dependencyCount &&
                             possiblyPeer.layerPlan === ancestry[possiblyPeer.layerPlan.depth]) {
                             possiblePeers.push(possiblyPeer);
                         }
@@ -1451,7 +1449,7 @@ class OperationPlan {
                 // We know the final dependency matches and the dependency count
                 // matches - check the other dependencies match.
                 for (let i = 0; i < dependencyCount - 1; i++) {
-                    if (deps[i] !== possiblyPeer.dependencies[i]) {
+                    if (deps[i] !== (0, utils_js_1.sudo)(possiblyPeer).dependencies[i]) {
                         continue outerloop;
                     }
                 }
@@ -1541,7 +1539,7 @@ class OperationPlan {
             case "nullableBoundary": {
                 // Safe to hoist _unless_ it depends on the root step of the nullableBoundary.
                 const $root = step.layerPlan.reason.parentStep;
-                if (step.dependencies.includes($root)) {
+                if ((0, utils_js_1.sudo)(step).dependencies.includes($root)) {
                     return;
                 }
                 else {
@@ -1580,7 +1578,7 @@ class OperationPlan {
             }
         }
         // Finally, check that none of its dependencies are in the same bucket.
-        const deps = step.dependencies;
+        const deps = (0, utils_js_1.sudo)(step).dependencies;
         if (deps.some((dep) => dep.layerPlan === step.layerPlan)) {
             return;
         }
@@ -1896,7 +1894,7 @@ class OperationPlan {
      */
     deduplicateStepsProcess(processed, start, step) {
         processed.add(step);
-        for (const dep of step.dependencies) {
+        for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
             if (dep.id >= start && !processed.has(dep)) {
                 this.deduplicateStepsProcess(processed, start, dep);
             }
@@ -2109,7 +2107,7 @@ class OperationPlan {
                 pending.delete(step);
                 const sideEffectDeps = [];
                 const rest = [];
-                for (const dep of step.dependencies) {
+                for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                     if (dep.layerPlan !== layerPlan) {
                         continue;
                     }
@@ -2142,7 +2140,7 @@ class OperationPlan {
                 processSideEffectPlan(sideEffectStep);
             }
             const readyToExecute = (step) => {
-                for (const dep of step.dependencies) {
+                for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                     if (dep.layerPlan === layerPlan && pending.has(dep)) {
                         return false;
                     }
@@ -2235,7 +2233,7 @@ class OperationPlan {
                 if (step_js_1.$$noExec in step) {
                     continue;
                 }
-                for (const dep of step.dependencies) {
+                for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                     ensurePlanAvailableInLayer(dep, layerPlan);
                 }
             }
@@ -2299,7 +2297,7 @@ class OperationPlan {
                 stepClass: step.constructor.name,
                 metaString: metaString ? (0, index_js_1.stripAnsi)(metaString) : metaString,
                 bucketId: step.layerPlan.id,
-                dependencyIds: step.dependencies.map((d) => d.id),
+                dependencyIds: (0, utils_js_1.sudo)(step).dependencies.map((d) => d.id),
                 polymorphicPaths: step.polymorphicPaths
                     ? [...step.polymorphicPaths]
                     : undefined,
@@ -2383,7 +2381,7 @@ class OperationPlan {
         const process = (lp, known) => {
             for (const step of this.stepTracker.activeSteps) {
                 if (step.layerPlan === lp) {
-                    for (const dep of step.dependencies) {
+                    for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                         if (!known.includes(dep.layerPlan)) {
                             // Naughty naughty
                             subroutineStep.addDependency(dep);

package/dist/engine/OutputPlan.d.ts

@@ -172,16 +172,4 @@ export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
 }
 export declare function coerceError(error: Error, locationDetails: LocationDetails, path: ReadonlyArray<string | number>): graphql.GraphQLError;
 export declare function nonNullError(locationDetails: LocationDetails, path: readonly (string | number)[]): graphql.GraphQLError;
-/**
- * We're currently running OutputPlan `outputPlan` in bucket `bucket` at index
- * `bucketIndex`. If this is an array OutputPlan then we're looping over the
- * entries in our list and we're currently at index `inArrayIndex` (otherwise
- * this is null).
- *
- * Now we want to run `childOutputPlan`, but to do so we need to find the
- * related `childBucket` and `childBucketIndex`.
- *
- * @internal
- */
-export declare function getChildBucketAndIndex(childOutputPlan: OutputPlan, outputPlan: OutputPlan | null, bucket: Bucket, bucketIndex: number, arrayIndex?: number | null): [Bucket, number] | null;
 //# sourceMappingURL=OutputPlan.d.ts.map

package/dist/engine/StepTracker.d.ts

@@ -1,96 +1,2 @@
-import type { OperationPlan } from "../index.js";
-import type { ExecutableStep } from "../step";
-import type { LayerPlan, LayerPlanReasonsWithParentStep } from "./LayerPlan";
-import type { OutputPlan } from "./OutputPlan";
-/**
- * This class keeps track of all of our steps, and the dependencies between
- * steps and other steps, layer plans and steps, and output plans and steps.
- *
- * When a step is replaced by another step, all the dependencies are updated
- * such that the replaced step simply evaporates.
- *
- * @internal
- */
-export declare class StepTracker {
-    private readonly operationPlan;
-    /** @internal */
-    stepCount: number;
-    /** @internal */
-    activeSteps: Set<ExecutableStep<any>>;
-    /** @internal */
-    stepById: {
-        [stepId: number]: ExecutableStep | null;
-    };
-    /** @internal */
-    private aliasesById;
-    /** @internal */
-    stepsWithNoDependencies: Set<ExecutableStep<any>>;
-    /** @internal */
-    outputPlansByRootStep: Map<ExecutableStep<any>, Set<OutputPlan<import("./OutputPlan").OutputPlanType>>>;
-    /** @internal */
-    layerPlansByRootStep: Map<ExecutableStep<any>, Set<LayerPlan<import("./LayerPlan").LayerPlanReason>>>;
-    /** @internal */
-    layerPlansByParentStep: Map<ExecutableStep<any>, Set<LayerPlan<LayerPlanReasonsWithParentStep>>>;
-    /** @internal */
-    layerPlans: Array<LayerPlan | null>;
-    /**
-     * All the OutputPlans that were created to allow a more efficient
-     * walkOutputPlans implementation.
-     *
-     * @internal
-     */
-    allOutputPlans: OutputPlan[];
-    nextStepIdToDeduplicate: number;
-    constructor(operationPlan: OperationPlan);
-    newStepsSince(oldStepCount: number): ExecutableStep<any>[];
-    private forbid;
-    /** Called when OperationPlan enters finalize phase. */
-    finalizeSteps(): void;
-    /** Called when OperationPlan is about to finalize the output plans. */
-    finalizeOutputPlans(): void;
-    addStep($step: ExecutableStep): number;
-    /**
-     * @internal
-     */
-    addLayerPlan(layerPlan: LayerPlan): number;
-    /**
-     * @internal
-     */
-    addOutputPlan(outputPlan: OutputPlan): void;
-    /**
-     * HIGHLY EXPERIMENTAL!
-     *
-     * @internal
-     */
-    deleteLayerPlan(layerPlan: LayerPlan): void;
-    getStepById(id: number): ExecutableStep;
-    getStepById(id: number, allowUnset: true): ExecutableStep | null;
-    addStepDependency($dependent: ExecutableStep, $dependency: ExecutableStep): number;
-    setOutputPlanRootStep(outputPlan: OutputPlan, $dependency: ExecutableStep): void;
-    setLayerPlanRootStep(layerPlan: LayerPlan, $dependency: ExecutableStep): void;
-    /** @internal */
-    replaceStep($original: ExecutableStep, $replacement: ExecutableStep): void;
-    treeShakeSteps(): void;
-    /**
-     * Return true if this step can be tree-shaken.
-     */
-    private isNotNeeded;
-    /**
-     * Only for use during planField.
-     */
-    purgeBackTo(count: number): void;
-    /**
-     * ONLY CALL THIS IF NOTHING DEPENDS ON $original! It's intended to be called
-     * from `replaceStep` or from itself.
-     *
-     * This method removes $original from the various maps/sets/lists, and also
-     * removes the fact that it was dependent on other steps. If these other
-     * steps no longer have any dependents (steps, layer plans or output plans)
-     * then they can also be eradicated _except_ during the 'plan' phase.
-     */
-    private eradicate;
-    moveStepToLayerPlan(step: ExecutableStep, targetLayerPlan: LayerPlan): void;
-    addStepToItsLayerPlan(step: ExecutableStep): void;
-    removeStepFromItsLayerPlan(step: ExecutableStep): void;
-}
+export {};
 //# sourceMappingURL=StepTracker.d.ts.map

package/dist/engine/StepTracker.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepTracker = void 0;
 const dev_js_1 = require("../dev.js");
 const interfaces_js_1 = require("../interfaces.js");
+const utils_js_1 = require("../utils.js");
 /**
  * We want everything else to treat things like `dependencies` as read only,
  * however we ourselves want to be able to write to them, so we can use
@@ -220,7 +221,7 @@ class StepTracker {
             throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the former is deleted!`);
         }
         this.stepsWithNoDependencies.delete($dependent);
-        const dependencyIndex = writeableArray($dependent.dependencies).push($dependency) - 1;
+        const dependencyIndex = writeableArray((0, utils_js_1.sudo)($dependent).dependencies).push($dependency) - 1;
         writeableArray($dependency.dependents).push({
             step: $dependent,
             dependencyIndex,
@@ -309,7 +310,7 @@ class StepTracker {
             if (dependents.length > 0) {
                 const replacementDependents = writeableArray($replacement.dependents);
                 for (const dependent of dependents) {
-                    writeableArray(dependent.step.dependencies)[dependent.dependencyIndex] = $replacement;
+                    writeableArray((0, utils_js_1.sudo)(dependent.step).dependencies)[dependent.dependencyIndex] = $replacement;
                     replacementDependents.push(dependent);
                 }
                 $original.dependents = [];
@@ -456,7 +457,7 @@ class StepTracker {
             this.stepById[$original.id] = null;
         }
         // Since this step is being removed, it doesn't need its dependencies any more
-        const oldDependencies = $original.dependencies;
+        const oldDependencies = (0, utils_js_1.sudo)($original).dependencies;
         for (const $dependency of oldDependencies) {
             // $dependency is no longer a dependent of $original, since we're getting
             // rid of $original

package/dist/engine/executeBucket.d.ts

@@ -1,8 +1,2 @@
-import type { Bucket, RequestTools } from "../bucket.js";
-import type { PromiseOrDirect } from "../interfaces.js";
-import type { MetaByMetaKey } from "./OperationPlan.js";
-/** @internal */
-export declare function executeBucket(bucket: Bucket, requestContext: RequestTools): PromiseOrDirect<void>;
-/** @internal */
-export declare function newBucket(spec: Pick<Bucket, "layerPlan" | "store" | "size" | "hasErrors" | "polymorphicPathList" | "iterators">, parentMetaByMetaKey: MetaByMetaKey | null): Bucket;
+export {};
 //# sourceMappingURL=executeBucket.d.ts.map