checkly 8.22.0 → 8.23.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * as constructs from './constructs/index.js';
 export { defineConfig } from './config.js';
 export type { ChecklyConfig } from './services/checkly-config-loader.js';
+export type { Registries as RunnerRegistries, Upstream as RunnerRegistryUpstream, UpstreamAuth as RunnerRegistryUpstreamAuth, PackageRoutingRule as RunnerRegistryPackageRoutingRule, } from './services/runner/registries.js';

package/dist/services/check-parser/bundler.d.ts

@@ -1,6 +1,9 @@
-import { EmbeddedPackagesMaterializer } from '../embedded-packages/materializer.js';
-import { ComputeWorkspaceCacheHashOptions } from './cache-hash.js';
+import { EmbeddedPackagesMaterializer, PlannedTarball } from '../embedded-packages/materializer.js';
+import { ComputeWorkspaceCacheHashOptions, EmbeddedPackageInput } from './cache-hash.js';
+import { BundlePackagesPrune } from './package-prune.js';
+import { PackageManager } from './package-files/package-manager.js';
 import { File } from './parser.js';
+import { Registries } from '../runner/registries.js';
 import { Workspace } from './package-files/workspace.js';
 export interface CreateBundleArchiveOptions {
     tempDir?: string;
@@ -60,23 +63,76 @@ export interface CreateBundlerOptions {
     stripPrefix?: string;
 }
 export type CreateBundlerForWorkspaceOptions = Omit<CreateBundlerOptions, 'cacheHash' | 'stripPrefix'> & Omit<ComputeWorkspaceCacheHashOptions, 'embeddedPackages'> & {
+    /**
+     * The project's `runner.registries` option, when set. Serialized into
+     * the bundle as {@link REGISTRIES_ARCHIVE_PATH} during finalize() so
+     * Checkly runners route the bundle's package installs through the
+     * configured upstreams, and mixed into the cache hash: repointing a
+     * registry changes the runner's install inputs without necessarily
+     * touching the lockfile.
+     */
+    runnerRegistries?: Registries;
     /**
      * The materializer for the project's `bundle.packages.embed` option,
-     * when set. Its resolved tarball set (name, version, integrity) is mixed
-     * into the cache hash: embedded tarballs change the runner's install-step
-     * inputs without necessarily touching the lockfile, so a changed embed
-     * set must invalidate the dependency cache.
+     * when set. The tarballs are materialized during finalize(), after the
+     * bundled lockfile has been pruned, so only tarballs the shipped
+     * lockfile still references are downloaded and shipped. That same
+     * filtered set (name, version, integrity) is mixed into the cache hash:
+     * embedded tarballs change the runner's install-step inputs without
+     * necessarily touching the lockfile, so a changed embed set must
+     * invalidate the dependency cache.
      */
     embeddedPackagesMaterializer?: EmbeddedPackagesMaterializer;
+    /**
+     * The workspace's package manager. When it supports a lockfile-only
+     * install, the bundled lockfile is pruned during finalize() to match the
+     * bundle's actual set of manifests.
+     */
+    packageManager: PackageManager;
+    /**
+     * The project's `bundle.packages.prune` option, when set. Matching
+     * entries are removed from the workspace manifests shipped in the
+     * bundle during finalize(), before lockfile pruning, so the removed
+     * dependencies fall out of the pruned lockfile too. The rewritten
+     * manifests are mixed into the cache hash the same way patch-rewritten
+     * manifests are. Because the rewritten manifests only make sense next
+     * to a matching lockfile, the rewrite is rolled back when a bundled
+     * lockfile cannot be pruned in the same run.
+     */
+    packagePrune?: BundlePackagesPrune;
 };
+/**
+ * Maps planned tarballs to cache-hash records. yarn.lock plans carry no SRI
+ * tarball integrity (it is resolved from registry metadata only at
+ * materialization time), so their records use the lockfile's own checksum —
+ * an equally stable content pin that is known at plan time, keeping the
+ * eager placeholder hash and the finalize hash consistent. The parsers
+ * guarantee one of the two hashes is always present; the empty-string
+ * fallback only satisfies the type.
+ */
+export declare function embeddedPackageHashInputs(tarballs: PlannedTarball[] | undefined): EmbeddedPackageInput[] | undefined;
 export declare class Bundler {
     #private;
     private constructor();
+    /**
+     * Creates a bundler without a workspace context. Workspace-dependent
+     * finalize() behavior — lockfile pruning, embedded package
+     * materialization (`bundle.packages.embed`) and the cache-hash recompute
+     * — only happens for bundlers built with {@link createForWorkspace}; a
+     * plain bundler archives exactly the files registered into it.
+     */
     static create(options: CreateBundlerOptions): Promise<Bundler>;
-    static createForWorkspace(workspace: Workspace, options?: CreateBundlerForWorkspaceOptions): Promise<Bundler>;
+    static createForWorkspace(workspace: Workspace, options: CreateBundlerForWorkspaceOptions): Promise<Bundler>;
     get marker(): BundlePathMarker;
     updateMarker(newValue: string): void;
-    get cacheHash(): string;
+    /**
+     * The dependency cache hash. A mutable holder rather than a plain string:
+     * consumers copy it into check payloads during bundle(), but the final
+     * value — reflecting faux manifests and a possibly pruned lockfile — is
+     * only known once finalize() has run, the same ordering problem
+     * {@link BundlePathMarker} solves for the archive path.
+     */
+    get cacheHash(): CacheHashMarker;
     /**
      * Whether any files have been registered for bundling. Only Playwright check
      * suites register files (see playwright-check.ts), so an empty bundler means the
@@ -92,3 +148,18 @@ export declare class BundlePathMarker {
     updateValue(newValue: string): void;
     toJSON(): string;
 }
+/**
+ * Mutable holder for the dependency cache hash, serialized as a plain
+ * string. See {@link Bundler.cacheHash} for why a holder is needed.
+ *
+ * Deliberately a standalone class rather than a subclass of
+ * {@link BundlePathMarker}: the own `#value` field makes the two marker
+ * types nominally incompatible, so a bundle path cannot be passed where the
+ * cache hash is expected (or vice versa) without a compile error.
+ */
+export declare class CacheHashMarker {
+    #private;
+    constructor(initialValue: string);
+    updateValue(newValue: string): void;
+    toJSON(): string;
+}