Changeset diffs are now computed from filesystem metadata instead of full-content comparison, significantly speeding up diff computation for large directories. by @marcosnils in
Fixed
Dockerfile build layer caching so unrelated build-context changes no longer bust the cache: COPY-ed directories now get a content-based cache identity, re-keying downstream steps only when copied content
Close this when the Python SDK is fully ready for 1.0 | Action | Status | PR | Comment | |---|---|---|---| | Module init | ✅ Done | — | We can initialize a module without problem with latest beta version. | | Client init | Missing | — | — | | Codegen for both | — | — | — | | Good default template | 🚧 | https://github.com/dagger/python-sdk/pull/10 | — | | No
Close this when the TypeScript SDK is fully ready for 1.0 | Action | Status | PR | Comment | |---|---|---|---| | Module init | ✅ Done | — | We can initialize a module without problem with latest beta version. | | Client init | ✅ Done | https://github.com/dagger/typescript-sdk/pull/9 and https://github.com/dagger/dagger/pull/13646 | Codegen is outside the eng
Close this when the Dang SDK is fully ready for 1.0 - Module init - Client init - Codegen for both - Good default template - SDK has full test coverage
Close this when the Java SDK is fully ready for 1.0 | Action | Status | PR | Comment | |---|---|---|---| | Module init | ✅ Done | — | We can initialize a module without problem with latest beta version. | | Client init | Missing | — | — | | Codegen for both | — | — | — | | Good default template | ✅ Done | https://github.com/dagger/java-sdk/pull/11 | — | | No
Related to, but not a duplicate of https://github.com/dagger/dagger/issues/13654 When a module is being developed for the 1.0.0-beta but still specifies an engineVersion of v0.x, there are two breaking error paths described below. The module can get into this broken state without the module author being aware because when using the module directly on 1.0.0-b
### What is the issue? `dagger module init <sdk> <name>` fails when the selected `dagger.toml` lives in a **subdirectory** of the git repo rather than at the git root: ``` Error: sdk module init: failed to call sdk module initModule: workspace path .dagger/modules/hello is outside changeset root common ``` This breaks the common monorepo layout where several
## What Adds a top-level `import` key to `dagger.toml`: a Git ref to another workspace whose configuration is merged **underneath** the current one. ```toml import = "github.com/acme/dagger-base@v1.2.0" # Only the difference from the base: [modules.go.settings] goVersion = "1.24" ``` A team can publish one base workspace config — shared tool versions, module
## Summary Implement #13464's package-manager-style latest-release lifecycle for Git repositories and container images. For Git: - add `GitRepository.latest` - select the greatest stable semantic-version tag, accepting both `v1.2.3` and `1.2.3` - ignore prerelease tags - fall back to the resolved remote HEAD when no stable release tag exists - load remote me
Follows #13845, which made `currentModule.asSDK`'s workspace argument required. This does the same for module functions. ## Problem Workspace arguments on module functions were published as nullable no matter how they were declared, because the engine injects one when the caller leaves it unset (`core/typedef.go`, plus two spots in `core/schema/module.go`).
## What this adds A detachable session is an engine session that keeps running after the client that created it disconnects. Ordinary Dagger sessions end when their main client disconnects. This PR adds an explicit opt-in mode where accepted work can continue, a later CLI can find and inspect the session, and the user terminates it explicitly. This is useful
`dagger/polyfill` currently fills a few gaps that now belong in the engine. This is the additive half of removing it. Tooling modules such as Pytest and Ruff need to find ordinary project roots on disk. `Workspace.findRoots` expresses that policy directly: find roots below the current directory, plus the nearest root above it. `glob` remains available when c
This completes the engine side of removing `dagger/polyfill`. `Workspace.changes()` now has one path contract: after the beta.10 cutover, paths are relative to the workspace cwd. This is true for every workspace, forked or not. Code that intentionally edits the repository root can make that explicit with `workspace.withWorkdir(".")`. `Workspace.fork()` only
## Summary Backport #13542 to the v0.21 maintenance line for v0.21.9. The Cloud keeper polls `engine { clients }` as part of its composite heartbeat. On v0.21, that enumeration can block behind one session lifecycle lock held across initialization or teardown. Because the keeper does not publish until the query returns, one slow session can suppress all keep
A `@check` that takes a required argument is silently dropped from `dagger check`. `dagger functions` lists it, `dagger check -l` doesn't, and nothing is said — a check that never ran looks exactly like a check that passed. Reproduced on `main` with a two-check module (`checks-required-arg`): ``` $ dagger functions needs-arg A @check with a required argument
## Summary - update `go.opentelemetry.io/otel/sdk` to v1.43.0 - update `google.golang.org/grpc` to v1.82.1 with its required transitive dependencies - refresh the Elixir Go runtime module sums These updates fix the current open Dependabot alerts for `sdk/elixir/runtime/go.mod`.
## Summary Backports https://github.com/dagger/dagger/pull/13681 to the v0.21 maintenance line for v0.21.9. When the main client's final connection closes, engine-internal session teardown is now scheduled on a background reaper. This keeps the `/shutdown` response from waiting on unbounded cache and resource reclamation, while the client-critical workspace/
## Summary Backport the scoped telemetry fix that hides normal registry-protocol HTTP probe failures from successful pull and publish progress. Registry HEAD 404s and auth challenges still occur as expected, but they no longer render as scary failed child rows when the enclosing registry operation succeeds. Also backport the shared private-GitLab test fixtur
## Summary - add absolute `maxEstimatedBytes` and `targetEstimatedBytes` controls to `Engine.localCache.prune`, including generated CLI and SDK surfaces - run configured structural-memory pruning inline with manual `useDefaultPolicy` requests when automatic GC is enabled, and allow explicit structural pruning when automatic GC is disabled - preserve legacy n
## Motivation Removing a result from a wide output equivalence class repeatedly scanned the class's digests and result postings while holding `egraphMu`. Release and metadata-prune work therefore grew superlinearly as the class widened, increasing lock contention for unrelated cache operations. ## Design This change adds three cache-owned derived indexes: -
# fix: make `dagger module init` work from a subdirectory workspace Fixes #13889. ## The bug With a `dagger.toml` in a subdirectory of the git repo — the monorepo layout, several projects under one root — `dagger module init` fails outright: ```console $ mkdir repo && cd repo && git init && mkdir common && touch common/dagger.toml $ cd common && dagger sdk i
> [!NOTE] > This unblocks CI repo-wide. `main` and every open PR are currently red. Chainguard moved the wolfi `helm` apk package to the 4.x line, so every `helm~3.18.4` constraint fails to resolve: ``` ERROR: unable to select packages: helm-4-4.2.3-r1: breaks: world[helm~3.18.4] ``` That breaks `ci:bootstrap`, `golang:test-all` (via `e2e/helm`), `helm:lint`
## What `dagger.toml` carries two path conventions that only coincide when the config file sits at the workspace root: - `[modules.<name>].source` resolves against the **config directory** (`ResolveModuleEntrySource`). - `[[modules.<sdk>.as-sdk.modules]].path` is **workspace-root-relative**, everywhere it is read: module→SDK ownership (`sdkOwnersByModulePath
# fix: classify dotted workspace-relative module refs as local ## Problem `dagger api client init <sdk> <client-path> <module-ref>` fails when the module ref is a workspace-root-relative path whose dot segment is not the first one: ```console $ dagger api client init go clients/api common/.dagger/mymod load module source: local path "common/.dagger/mymod" do