@pikku/azure-functions 0.12.8 → 0.12.10

package/dist/azure-deployment-service.js.map

@@ -1 +1 @@
-{"version":3,"file":"azure-deployment-service.js","sourceRoot":"","sources":["../src/azure-deployment-service.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,OAAO,sBAAsB;IAIvB;IACA;IAJF,QAAQ,CAAqB;IAErC,YACU,GAA2B,EAC3B,OAAsB,EAC9B,gBAAwC;QAFhC,QAAG,GAAH,GAAG,CAAwB;QAC3B,YAAO,GAAP,OAAO,CAAe;QAG9B,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAA;IAC3D,CAAC;IAED,KAAK,CAAC,IAAI,KAAmB,CAAC;IAC9B,KAAK,CAAC,KAAK,CAAC,OAAyB,IAAkB,CAAC;IACxD,KAAK,CAAC,IAAI,KAAmB,CAAC;IAE9B,KAAK,CAAC,MAAM,CACV,QAAgB,EAChB,IAAa,EACb,OAAiB,EACjB,OAAgB;QAEhB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAC/C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,2CAA2C,QAAQ,KAAK;gBACtD,uBAAuB,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAChE,CAAA;QACH,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,kBAAkB,CACtC,IAAI,CAAC,GAAG,EACR,IAAI,CAAC,OAAO,EACZ,QAAQ,EACR,OAAO,EACP,OAAO,CACR,CAAA;QAED,MAAM,GAAG,GAAG,GAAG,WAAW,eAAe,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAA;QACvE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAChC,MAAM,EAAE,MAAM;YACd,OAAO;YACP,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC;SAC/B,CAAC,CAAA;QAEF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,IAAI,SAAiB,CAAA;YACrB,IAAI,CAAC;gBACH,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;YACnD,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;YACnC,CAAC;YACD,MAAM,IAAI,KAAK,CACb,uBAAuB,QAAQ,aAAa,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,KAAK,SAAS,EAAE,CACnG,CAAA;QACH,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAA;IACxB,CAAC;CACF"}
+{"version":3,"file":"azure-deployment-service.js","sourceRoot":"","sources":["../src/azure-deployment-service.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,OAAO,sBAAsB;IAIvB,GAAG;IACH,OAAO;IAJT,QAAQ,CAAqB;IAErC,YACU,GAA2B,EAC3B,OAAsB,EAC9B,gBAAwC;mBAFhC,GAAG;uBACH,OAAO;QAGf,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAA;IAC3D,CAAC;IAED,KAAK,CAAC,IAAI,KAAmB,CAAC;IAC9B,KAAK,CAAC,KAAK,CAAC,OAAyB,IAAkB,CAAC;IACxD,KAAK,CAAC,IAAI,KAAmB,CAAC;IAE9B,KAAK,CAAC,MAAM,CACV,QAAgB,EAChB,IAAa,EACb,OAAiB,EACjB,OAAgB;QAEhB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAC/C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,2CAA2C,QAAQ,KAAK;gBACtD,uBAAuB,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAChE,CAAA;QACH,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,kBAAkB,CACtC,IAAI,CAAC,GAAG,EACR,IAAI,CAAC,OAAO,EACZ,QAAQ,EACR,OAAO,EACP,OAAO,CACR,CAAA;QAED,MAAM,GAAG,GAAG,GAAG,WAAW,eAAe,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAA;QACvE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAChC,MAAM,EAAE,MAAM;YACd,OAAO;YACP,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC;SAC/B,CAAC,CAAA;QAEF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,IAAI,SAAiB,CAAA;YACrB,IAAI,CAAC;gBACH,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAA;YACnD,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;YACnC,CAAC;YACD,MAAM,IAAI,KAAK,CACb,uBAAuB,QAAQ,aAAa,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,KAAK,SAAS,EAAE,CACnG,CAAA;QACH,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAA;IACxB,CAAC;CACF"}

package/dist/pikku-az-functions-logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"pikku-az-functions-logger.js","sourceRoot":"","sources":["../src/pikku-az-functions-logger.ts"],"names":[],"mappings":"AAIA,MAAM,OAAO,kBAAkB;IAGT;IAApB,YAAoB,OAA0B;QAA1B,YAAO,GAAP,OAAO,CAAmB;IAAG,CAAC;IAE3C,IAAI,CACT,YAAqB,EACrB,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,YAAmB,EAAE,GAAG,IAAI,CAAC,CAAA;IACjD,CAAC;IAEM,IAAI,CACT,YAAqB,EACrB,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,YAAmB,EAAE,GAAG,IAAI,CAAC,CAAA;IACjD,CAAC;IAEM,KAAK,CAGV,YAAqB,EAAE,GAAG,IAAoC;QAC9D,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,YAAmB,EAAE,GAAG,IAAI,CAAC,CAAA;IAClD,CAAC;IAEM,KAAK,CACV,OAAe,EACf,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAA;IACtC,CAAC;IAEM,KAAK,CACV,OAAe,EACf,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAA;IACtC,CAAC;IAEM,QAAQ,CAAC,KAAe;IAE/B,CAAC;CACF"}
+{"version":3,"file":"pikku-az-functions-logger.js","sourceRoot":"","sources":["../src/pikku-az-functions-logger.ts"],"names":[],"mappings":"AAIA,MAAM,OAAO,kBAAkB;IAGT,OAAO;IAA3B,YAAoB,OAA0B;uBAA1B,OAAO;IAAsB,CAAC;IAE3C,IAAI,CACT,YAAqB,EACrB,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,YAAmB,EAAE,GAAG,IAAI,CAAC,CAAA;IACjD,CAAC;IAEM,IAAI,CACT,YAAqB,EACrB,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,YAAmB,EAAE,GAAG,IAAI,CAAC,CAAA;IACjD,CAAC;IAEM,KAAK,CAGV,YAAqB,EAAE,GAAG,IAAoC;QAC9D,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,YAAmB,EAAE,GAAG,IAAI,CAAC,CAAA;IAClD,CAAC;IAEM,KAAK,CACV,OAAe,EACf,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAA;IACtC,CAAC;IAEM,KAAK,CACV,OAAe,EACf,GAAG,IAAoC;QAEvC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAA;IACtC,CAAC;IAEM,QAAQ,CAAC,KAAe;IAE/B,CAAC;CACF"}

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@pikku/azure-functions",
-  "version": "0.12.8",
+  "version": "0.12.10",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/runtimes/azure-functions"
+  },
   "description": "Azure Functions runtime for Pikku — HTTP, timer and storage-queue handlers",
   "license": "MIT",
   "author": "yasser.fadl@gmail.com",
@@ -10,27 +15,30 @@
   "scripts": {
     "tsc": "tsc && tsc -p tsconfig.type-tests.json",
     "ncu": "npx npm-check-updates",
-    "build": "tsc -b",
+    "build": "bun run clean && tsc -b",
     "release": "npm run build && npm test",
     "test": "bash run-tests.sh",
     "test:watch": "bash run-tests.sh --watch",
     "test:coverage": "bash run-tests.sh --coverage",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "bun run build",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.87"
-  },
-  "devDependencies": {
-    "typescript": "^6.0.3"
+    "@pikku/core": "^0.12.144"
   },
   "engines": {
     "node": ">=24"
   },
   "dependencies": {
-    "@azure/functions": "4.16.2",
-    "@azure/storage-queue": "^12.31.0"
+    "@azure/functions": "4.16.5",
+    "@azure/storage-queue": "^12.32.0"
   },
   "exports": {
-    ".": "./dist/index.js"
-  }
-}
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ]
+}

package/CHANGELOG.md

@@ -1,625 +0,0 @@
-## 0.12.8
-
-### Patch Changes
-
-- 3a83f85: Stop re-exporting package internals through entry points
-
-  66 names reached consumers only because an `export *` in an entry point swept
-  them up. Each one is referenced solely inside its own package, so the star is
-  now an explicit named re-export listing what is genuinely public. The
-  declarations themselves are untouched — this narrows the entry point, not the
-  module.
-
-- Updated dependencies [9687ad1]
-- Updated dependencies [2d21628]
-- Updated dependencies [985b87b]
-- Updated dependencies [3a83f85]
-  - @pikku/core@0.12.87
-
-## 0.12.7
-
-### Patch Changes
-
-- 266e3bc: One door per name: `@pikku/core/ecosystem/*` and the package root are gone
-
-  `@pikku/core` published every module twice. `ecosystem/http` re-exported
-  `./http`, `ecosystem/services` re-exported `./services`, and a name was
-  reachable through either — so every addition had to be made in two places, and a
-  consumer's import said nothing about what it actually used. The package root was
-  the same problem at a larger scale: a single barrel of 206 names that no bundler
-  could take apart, and the one specifier that revealed nothing at all.
-
-  Both are deleted. Every name now lives on the subpath that owns it, and every
-  import carries that subpath — `@pikku/core/http`, `@pikku/core/services`,
-  `@pikku/core/errors`, `@pikku/core/types`.
-
-  Deleting the facades meant the raw subpaths had to become a superset of them,
-  which they were not: the facade tree had accumulated 25 names with no raw home
-  and about 26 more filed under a different area than the module they came from.
-  Those names moved to the area that owns them, and three areas were published as
-  new entry points rather than left on a root that is going away — `./types` (the
-  shared type surface, the largest single destination), `./state` and
-  `./classification`.
-
-  `./classification` is one door onto one subject: what a value is and how it must
-  be handled. Its three halves would each have been an entry point — the brands
-  and manifest types, the stored-form helpers (`hashToken`, `unsafeAsSealed` and
-  friends), and `SecretValue` — split by whether a name happens to be a type or a
-  value, which is the same defect as the facades. The duration and versioned-id
-  helpers went to `./utils`, which already published, and `PikkuRequest` went to
-  `./function`: it is the transport-agnostic request base, not an HTTP one — HTTP
-  has `PikkuHTTPAbstractRequest`, and the only thing outside core that extends
-  `PikkuRequest` is Azure's timer request.
-
-  `./types` inherited the root barrel's habit before it inherited its contents, so
-  the names with an owner elsewhere were moved off it. The middleware types and the
-  five middleware factories — `pikkuMiddleware`, `pikkuMiddlewareFactory`,
-  `pikkuChannelMiddleware`, `pikkuChannelMiddlewareFactory` and
-  `pikkuAgentMiddleware`, runtime values on a types entry point — are now
-  `@pikku/core/middleware`; the function meta types are `@pikku/core/function`;
-  `SerializedError` is `@pikku/core/errors`; and the generic TypeScript helpers
-  (`MakeRequired`, `PickRequired`, `PickOptional`, `RequireAtLeastOne`,
-  `JSONPrimitive`, `JSONValue`) are `@pikku/core/utils`. What is left on `./types`
-  is the vocabulary the wirings share, which no single module owns.
-
-  `pikku` was itself a root barrel — `export * from '@pikku/core'` — and
-  now exports only the services it bundles.
-
-  One module survives at the old specifier, and only for the bootstrap:
-  `packages/cli` is generated by the _published_ CLI pinned in its `build.sh`, and
-  that CLI still writes a bare `@pikku/core` into the files it generates for the
-  CLI itself. `bootstrap-compat/root.ts` carries the eight types it names, a test
-  in core fails if that list grows, and it goes when the pin moves to a CLI
-  released from this branch. The adapter names the pinned CLI reaches for —
-  `pikkuState` and `CreateWireServices` — are rewritten to `@pikku/core/state` and
-  `@pikku/core/types` by the same `build.sh` patch pass, so no second shim is
-  needed for them.
-
-  A guard test keeps the root shut: it parses imports and rejects a bare
-  `@pikku/core` rather than grepping for it, because several tests hold a user's
-  file as a template literal, where `import … from '@pikku/core'` is fixture text
-  rather than an import this repo makes.
-
-  An agent scaffold a project generated under an older CLI is refreshed rather
-  than left to fail: `pikku all` already deleted one importing an entry point
-  `@pikku/core` no longer publishes, and the `#pikku` hub joins that list.
-  Without it a project that scaffolds the agent endpoint but
-  declares no agents keeps the old file forever — the generator that would rewrite
-  it only runs when agents exist, and the file being present is what stops it
-  being regenerated as missing.
-
-  `pikku new addon` also wrote a tsconfig `paths` map naming only the deleted hub.
-  An addon's `imports` map points into `dist`, so `paths` is what resolves
-  `#pikku/<leaf>` for the addon's own source build — it now names the two leaf
-  patterns, in both the addon and its test harness.
-
-- 6eef0a0: Bump every dependency to its latest compatible minor/patch across the monorepo.
-- Updated dependencies [7722ceb]
-- Updated dependencies [375c1ff]
-- Updated dependencies [02a70cd]
-- Updated dependencies [aeef159]
-- Updated dependencies [a281de6]
-- Updated dependencies [266e3bc]
-- Updated dependencies [02a70cd]
-- Updated dependencies [786dae5]
-- Updated dependencies [6eef0a0]
-- Updated dependencies [3561d67]
-- Updated dependencies [a91c433]
-- Updated dependencies [02a70cd]
-- Updated dependencies [9537f74]
-- Updated dependencies [2b57ca8]
-- Updated dependencies [266e3bc]
-- Updated dependencies [9fce0f1]
-- Updated dependencies [83683a0]
-- Updated dependencies [456c88b]
-- Updated dependencies [456c88b]
-- Updated dependencies [c127273]
-  - @pikku/core@0.12.85
-
-## 0.12.6
-
-### Patch Changes
-
-- 6794681: Publish the ecosystem surface as per-area sub-barrels under `@pikku/core/ecosystem/*`, and point generated code, the CLI, the inspector and the runtime adapters at them.
-
-  348 names that only generated code, the toolchain or a runtime adapter ever imports now have a second home on `@pikku/core/ecosystem/<area>` — one sub-barrel per area, matching how core already publishes its entrypoints, so no single barrel grows without bound and a consumer only pulls in the area it uses.
-
-  This step is additive: every name is still exported from the entrypoint it was published from before, so nothing downstream breaks. Removing them from the app-facing barrels is a later change, and needs a release carrying `./ecosystem/*` first.
-
-- Updated dependencies [7406bfe]
-- Updated dependencies [6794681]
-  - @pikku/core@0.12.84
-
-## 0.12.5
-
-### Patch Changes
-
-- 78b29f0: `SecretService` now returns a `SecretValue<T>` rather than the bare value, so a
-  vault secret cannot reach a sink by accident.
-
-  `SecretValue` is nominally typed, which means it is not assignable to `string`
-  (or to any other concretely-typed field). Every sink with a real type — a
-  database column, an email body, a session payload — rejects it with no lint
-  rule involved. The sinks typed `any`, `unknown`, or a free generic — the logger,
-  queue payloads, webhook and email inputs, and a function's own output — are
-  guarded with `Safe<T>`, which collapses a `SecretValue` found anywhere inside
-  `T`, however deeply nested, to `never`.
-
-  Unwrap deliberately at the point the secret reaches the wire:
-
-  ```ts
-  const secret = await secrets.getSecret('BETTER_AUTH_SECRET')
-  betterAuth({ secret: secret.reveal() })
-  ```
-
-  Two behaviours cover what types cannot see. Structured serialization redacts —
-  `JSON.stringify` and node's inspect both yield `[secret]`, so an audit or log
-  write stays honest without crashing the request. String coercion throws
-  `SecretCoercionError`, because a template literal is always a leak.
-
-  `AuditLog.write` is guarded the same way as the logger, since an audit event
-  carries `input` and `metadata` as `unknown` and nominality alone cannot stop a
-  secret landing in one.
-
-  `.reveal()` is the deliberate escape hatch, and what it hands back is an
-  ordinary string as far as every sink signature is concerned. **PKU953** closes
-  that gap: under `pikku all --security` the inspector reports a revealed secret
-  that flows into a logger, an audit, a queue, an email or a webhook — `console` included.
-
-  This also fixed a real one: `remote-addon-auth.ts` called `String(token)` on an
-  `unknown` and wrote the result straight into an `Authorization` header.
-
-- Updated dependencies [62ea4cc]
-- Updated dependencies [9dddff8]
-- Updated dependencies [78b29f0]
-  - @pikku/core@0.12.76
-
-## 0.12.4
-
-### Patch Changes
-
-- afef587: Close eleven security weaknesses found in a review of `@pikku/core`. Most are
-  breaking, and two invalidate data or credentials already in the wild — read the
-  migration notes before upgrading.
-
-  **Breaking: AI agent thread ownership now fails closed.** Reading, listing,
-  resuming or approving an existing thread or run requires a resolved session
-  principal (`userId`, or `orgId` for `sessionScope: 'org'`), regardless of the
-  agent's `auth` setting. Previously a request without a session had no ownership
-  model at all: the caller-supplied `resourceId` was accepted as the ownership
-  key, so any caller could read or resume another party's thread by naming its
-  `resourceId`. Worse, `threadOwnerConstraint` returned `undefined` for a
-  sessionless caller, and `undefined` means _no filter_ rather than _no rows_ —
-  so `getAgentThreads` returned every thread in the deployment. It now returns
-  `string[]`, empty for a sessionless caller, which every storage backend already
-  treats as matching nothing. Sessionless agents still run one-shot conversations,
-  each with a fresh unguessable owner; what they lose is cross-request continuity.
-  Wire a session to restore it.
-
-  **Breaking: stored secrets and credentials must be re-entered.** `deriveKey` ran
-  a single unsalted round of SHA-256 over the passphrase and used the digest
-  directly as the AES-GCM key — roughly one hash per brute-force guess, with one
-  rainbow table working against every deployment. It is now PBKDF2-HMAC-SHA256 at
-  600,000 iterations over a random salt. There is no compatibility path: every
-  value held by the kysely, mongodb and redis secret services and the kysely
-  credential service becomes undecryptable. They fail loud, naming the key and
-  `key_version`, so the app hard-fails on first secret read until each is re-set.
-
-  The KEK salt is scoped to the key version and stored alongside it, rather than
-  per secret, so a bulk read costs one derivation instead of N — `getSecrets` over
-  50 secrets went from ~2.3s to ~48ms, and rotation from ~4.6s to ~94ms. This adds
-  a salt table (kysely), hash field (redis) or collection (mongodb), created
-  automatically on first use.
-
-  **Breaking: `PIKKU_REMOTE_SECRET` must be at least 32 characters.** The
-  remote-RPC session envelope moved from PBKDF2 to HKDF, which expands
-  high-entropy key material rather than stretching a low-entropy passphrase. That
-  took a remote hop from ~269ms to ~0.4ms — PBKDF2 was running twice per request —
-  but HKDF supplies no brute-force resistance, so the secret must carry the
-  entropy itself. A shorter secret now throws `WeakKeyMaterialError` at both ends.
-  Generate one with `openssl rand -base64 32` and roll it out to every service in
-  the mesh together: existing bearer tokens are format-incompatible, so a partial
-  rollout produces 401s until every instance is updated. The Cloudflare, Lambda
-  and Azure deployment services each hand-rolled a copy of `buildRemoteHeaders`
-  and now call the shared one, which is what keeps the two sides in step.
-
-  **Breaking: previously signed content URLs stop verifying.** `LocalContent`
-  signed only `{signedAt, expiresAt, notBefore}`, so a signature proved when a URL
-  was issued but never what it was issued for — any valid token was a skeleton
-  key, and swapping the pathname from a public thumbnail to a private document
-  still verified. The signature now binds the request path. Separately, the
-  verifier returned "valid" when no JWT service was wired, which is how
-  `pikku serve` ran: a forged `?signedAt=0&expiresAt=99999999999999` was accepted.
-  It now rejects with 403, `LocalContent` requires a `JWTService`, and
-  `pikku serve`/`pikku dev` mint an ephemeral per-process signing key so local
-  development works without shipping a fail-open path. In-flight signed URLs must
-  be re-issued.
-
-  **Request body size limits now apply to every adapter.** The `maxBodySize` cap
-  existed only in `PikkuFetchHTTPRequest`. The real hole was uWebSockets, which
-  drove `res.onData` itself and concatenated every chunk with no bound and nothing
-  downstream able to intervene; it now drops chunks past the limit and replies 413
-  before routing. Fastify delegates to its native `bodyLimit` (set only when
-  `maxBodySize` is configured, so fastify's stricter 1 MB default is never
-  loosened), and `PikkuExpressServer` feeds the limit into its body parsers. Two
-  paths can only reject rather than prevent, and are documented as such:
-  `express-middleware` mounted on your own app receives an already-parsed body, so
-  that deployment must bound its own parser; Next server actions bottom out at
-  `experimental.serverActions.bodySizeLimit`.
-
-  **Breaking: the console addon's privileged functions are gated by default.**
-  `wireAddon` gains a `scopes` option that applies to every function in the
-  addon's namespace, and the console scaffold now generates
-  `wireAddon({ name: 'console', package: '@pikku/addon-console', scopes: ['admin'] })`.
-  Previously the console's entire privileged surface — around 54 functions
-  including `credentialGet`, which returns a resolved OAuth token for an arbitrary
-  `userId`, `updateFunctionBody`, and `installAddon`, which shells out to a
-  package install — was protected only by an optional host-registered
-  `addGlobalPermission`. `resolveGlobalPermissions` returns `[]` when none is
-  registered and permission checking then no-ops, so an app that never registered
-  one served those functions to anyone, and with the template's default
-  `scaffold.rpc: "no-auth"` that meant unauthenticated. All of them now return 403
-  `MissingScopeError` without an `admin`, `admin:*` or `*` scope. **Regenerating
-  is required** — an app holding an old `console.gen.ts` stays open.
-  `installAddon` and `installOpenapiAddon` additionally declare their own
-  `auth: true, scopes: ['admin']`, and `getAgentThreads` now scopes its listing to
-  the session's own threads unless the caller holds admin.
-
-  Addon scopes are enforced in `runPikkuFunc` rather than at the RPC boundary,
-  because a wiring can reference an addon function directly — the inspector
-  records the addon's `packageName` on HTTP, channel, schedule, queue, CLI,
-  trigger, gateway and MCP wirings — and those paths never call `resolveNamespace`.
-  Enforcing at the RPC seam would have covered only the `namespace:function` form
-  while reading as complete.
-
-  **Breaking: `wireAddon`'s `auth` and `tags` now apply on direct wirings too.**
-  Both were read only by `resolveAddonFunction`, so they had exactly the hole
-  scopes had: `wireAddon({ name: 'console', package: '@pikku/addon-console', auth:
-true, tags: ['admin'] })` gated `rpc('console:credentialGet')` and gated nothing
-  at all on an HTTP route wired straight to `credentialGet`. A consumer who
-  reached for the documented way to lock an addon down got a control that was
-  silently inert on every wiring except one. Both now resolve in `runPikkuFunc`.
-  `auth` merges as an OR — `auth: false` from an addon is ignored on a direct
-  wiring, because an addon may require a session the wiring did not but must never
-  waive one it did. Addon tags resolve to concrete middleware against the **root**
-  tag groups before the call rather than being folded into the function's
-  inherited middleware: `addTagMiddleware('admin', …)` is written by the consuming
-  app and registers under the root package, whereas `combineMiddleware` would look
-  the tag up under the addon's own `packageName`, where it does not exist.
-
-  One consequence worth naming: an addon that wires `auth: true` and also runs its
-  own sessionless internal work — a scheduled task or queue worker inside the
-  addon calling a sibling function — is now gated where it previously was not,
-  because a bare `rpc('fn')` from inside the addon reaches `runPikkuFunc` with the
-  addon's `packageName` like any other call. This reverses a decision that
-  deliberately scoped the gate to the namespaced boundary; that reasoning held
-  only while the boundary was real, and a direct wiring can enter an addon without
-  crossing it, so "already inside" is not something the runtime can infer. Such an
-  addon should carry authorization on the function via
-  `pikkuFunc({ permissions })`, which has always been enforced on every path. A
-  follow-up will add execution provenance so an intra-addon call can be
-  distinguished from an external one and skip the addon-level check; that needs a
-  marker no caller outside the process can set, which is its own design problem
-  and does not belong in a security fix.
-
-  **Codegen now warns when an exposed function has no gate (PKU574).** The
-  generated `POST /rpc/:rpcName` dispatcher forwards to `rpc.exposed`, which
-  refuses anything without `expose: true` — but nothing checked whether the
-  target was gated, because a dispatcher cannot know what it dispatches to. The
-  console shipped ~54 privileged functions through that gap and the toolchain was
-  silent. The inspector now reports every function that is exposed, sessionless,
-  and carries no `auth`, `scopes` or `permissions` of its own and none from a
-  governing `wireAddon`. It is a `warn`, not a critical: `expose: true` on an
-  ungated sessionless function is correct for a genuinely public endpoint, so it
-  blocks a build only under `--fail-on-warn`.
-
-  Two pieces of metadata were missing for this to be answerable statically, and
-  both are now recorded. A `pikkuSessionlessFunc`'s own `auth: true` was read at
-  runtime but never written to function meta, so a self-gated function was
-  indistinguishable from an ungated one — `sessionless` carries the baseline, and
-  `auth` now carries the tightening. And `wireAddon`'s `scopes`, `auth` and `tags`
-  were not parsed at all: the inspector recorded the addon's `rpcEndpoint` and its
-  secret, variable and credential overrides, and dropped every one of its gates.
-  An addon whose gates are not statically knowable is treated as gated, because a
-  false positive on a correctly-secured addon costs more than the one case it
-  would catch.
-
-  **Breaking: an application's global permissions now apply inside addons.**
-  `resolveGlobalPermissions` read only the bucket matching the function's own
-  package, but the generated `addGlobalPermission` wrapper takes no package
-  argument and always registers under the root. An app-wide rule like "every
-  request needs a signed-in user" therefore stopped at the addon boundary, and the
-  bucket an addon's functions did read was one no host could write to — which is
-  why the console addon's recommended `addGlobalPermission([isAdmin],
-'@pikku/addon-console')` was never a gate anybody could actually install. A
-  function now resolves the root bucket and its own package's, root first.
-  Unioning is safe in a way nothing else here would be: globals AND, so adding the
-  root ones can only tighten. Package buckets stay one-way — a package's globals
-  never reach root functions, or an installed addon could gate the whole
-  application. Apps with both a root global and addon-provided functions will see
-  those functions gated where they previously were not.
-
-  **Codegen now records whether each HTTP route requires a session, and warns
-  about inert addon tags (PKU575).** Four separate things can demand a session —
-  the function's `sessionless`, its own `auth`, the route's (or its group's)
-  `auth`, and the addon it belongs to — and answering "which routes are open?"
-  meant joining all four by hand and knowing which wins. Each route's meta now
-  carries the resolved `requiresSession` alongside the route's own `auth`. Scopes
-  count as requiring one, since they are matched against the session's and fail
-  closed. Anything not statically knowable resolves to `true`, matching PKU574:
-  a route that looks stricter than it is costs less than one that looks open and
-  isn't. Separately, `wireAddon({ tags: ['admin'] })` reads like a gate and is
-  applied like one right up until no `addTagMiddleware('admin', …)` exists, at
-  which point it resolves to an empty list and gates nothing; that now warns.
-  Only addon tags are reported — a tag on a function is as likely to be
-  organizational, and warning about those would bury the case that matters.
-
-  **Object-shorthand permissions were missing from meta.** The inspector visited
-  `ts.PropertyAssignment` but not `ts.ShorthandPropertyAssignment`, so
-  `permissions: { canAdminOrg }` — enforced identically to the longhand form at
-  runtime, since `verifyPermissions` has a non-array branch — was recorded as _no
-  permissions at all_. That is the most dangerous direction for meta to be wrong
-  in: an audit reading it sees an open door where one is shut. It cost this review
-  a false IDOR report across ~35 billing and org functions before the source
-  contradicted the metadata.
-
-  **Functions that authorize in their own body can say so.** A webhook receiver
-  verifying a signature, or a handler redeeming a signed invite, is genuinely
-  closed while carrying no session, scope or permission — indistinguishable in
-  meta from one nobody remembered to gate, and so warned about forever by PKU574.
-  `selfAuthenticated: true` on the function config records the claim and silences
-  the warning for that function. It is declarative only: nothing at runtime reads
-  it and it grants nothing. Detection was rejected deliberately — inferring it
-  from the body means a function that _looks_ like it checks something silences
-  the warning while checking nothing, and a warning that is usually wrong stops
-  being read.
-
-  **Breaking: `scaffold.<feature>` is now `boolean | { auth?, path? }`, and `true`
-  means authenticated.** The old `'auth' | 'no-auth' | false` read like a
-  starter-file preference while being a live authorization decision, set three
-  directories from the functions it governed — the shape the console incident
-  took. A surface now becomes public only by writing `{ auth: false }`, so
-  omitting a field can never open anything: the failure mode of a forgotten flag
-  is a locked door. `{ path }` additionally overrides where the file is
-  generated, which previously could only be set for all features at once via
-  `pikkuDir`.
-
-  The legacy strings are **refused, not coerced**. `resolveScaffoldFeature` throws
-  naming the key and its replacement (`"rpc": "no-auth"` → `"rpc": { "auth":
-false }`), and it does so at config load, not downstream. An earlier design used
-  a bare `string` for the output path, under which `"no-auth"` would have parsed
-  as a file named `no-auth` and every unmigrated config would have silently
-  produced nonsense; the object form makes any string invalid, so the failure is
-  loud.
-
-  The collapse is deliberately not uniform in effect. For `rpc` the flag was a
-  blanket "no anonymous RPC in this app" set on a dispatcher that cannot know what
-  it dispatches to; for `userAdmin` it was redundant, since the generated
-  functions are already `pikkuFunc` with `scopes: ['admin:users:list']`. But for
-  `agent`, `workflow`, `events` and `scenarios` it is the only gate — those
-  generate real endpoints the app never authors — so `true` keeps them
-  authenticated rather than opening them as a side effect of a config cleanup.
-  `webhook` and `remoteRpc` have no auth dimension at all (`serialize-remote-rpc.ts`
-  hardcodes `auth: false`), so an `{ auth }` on them is ignored. The three
-  configs in this repo are migrated preserving their current behaviour exactly.
-
-  **Queue job identities are signed.** A job carried the producer's `pikkuUserId`
-  as a plain string and the worker resolved a session from it with no
-  verification, so write access to the queue backend was act-as-any-user. The
-  identity is now `pq1.<claim>.<hmac>`, HMAC-SHA256 over the claim and the
-  canonicalized job payload, keyed by HKDF expansion of a new
-  `PIKKU_QUEUE_IDENTITY_SECRET`. Producers opt in by wrapping their queue service
-  with `SignedQueueService`. This fails safe rather than closed: with no secret
-  configured the identity is dropped and jobs still process, warning once per
-  process, so no existing deployment breaks on upgrade — it simply loses queue
-  identity until the secret is set. The payload rather than the job id is bound
-  because SQS, Cloudflare Queues, Azure and the in-memory service all mint ids
-  after `add` returns.
-
-  **Workflow inline state is read from the run record.** `isInline` consulted a
-  process-local `Map`, while `WorkflowRun.inline` is durable. Any instance that
-  did not start a run disagreed with the record, so one instance could dispatch a
-  queued job for a workflow another was already executing in-process. It is now
-  async and resolves through the durable identity, cached only when a context
-  already exists so a passive reader allocates nothing. The same `Map` also leaked:
-  `nextStepKey` fabricated replay state on every step, and `releaseContext`
-  refused to free anything carrying it, so runs whose steps executed outside a
-  `beginReplay` bracket — the step-worker queue path — stranded their context and
-  step state for the process lifetime. Contexts are now released by an explicit
-  execution counter. Step ordinals reset per execution rather than accumulating
-  across step-worker invocations in one process, which makes step naming
-  independent of how work was distributed.
-
-  **Secret reads fail loud in every store.** `MongoDBSecretService.getSecrets`
-  skipped rows that failed to decrypt, and the redis equivalent dropped every
-  rejection via `Promise.allSettled`, including the "No KEK available for
-  key_version N" configuration error. Both now throw, naming the key and its key
-  version, matching the kysely behaviour. This matters most alongside the KEK
-  change above: without it, an upgrade surfaces as a partial secrets map and an
-  opaque downstream failure instead of an error naming the secret to re-enter.
-
-  **A second middleware registration for a pattern no longer erases the first.**
-  `addHTTPMiddleware`, `addTagMiddleware` and `addChannelMiddleware` groups are
-  keyed by pattern or tag and held one source file each, so a second file's call
-  overwrote the first's. Codegen emits its imports from what is stored, so the
-  losing file was never imported and its middleware never registered — the
-  runtime composes repeated registrations for a pattern happily, and only codegen
-  dropped one. Adding an unrelated `addHTTPMiddleware('*', …)` to an app was
-  enough to silently unregister the generated better-auth session bridge, which
-  fails open and gives no sign until a request arrives without a session. A group
-  now carries every registration made for it, and all of them are imported.
-
-- Updated dependencies [6a307f0]
-- Updated dependencies [afef587]
-- Updated dependencies [8075f6a]
-  - @pikku/core@0.12.74
-
-## 0.12.3
-
-### Patch Changes
-
-- daec082: Drop Node 22 support — the minimum supported runtime is now Node 24 (LTS).
-
-  Node 22 deadlocks `pikku dev` at `loadUserBootstrap` (tsx `register()` + `require(esm)` cycle handling on node 22.12+), and Node 20 is already below our floor. The `engines.node` requirement is raised to `>=24` across all packages, matching `.nvmrc` and the CI test matrix. Closes #751.
-
-- Updated dependencies [7b17b14]
-- Updated dependencies [daec082]
-- Updated dependencies [e0fd352]
-  - @pikku/core@0.12.58
-
-## 0.12.2
-
-### Patch Changes
-
-- 41ce2cb: Upgrade to TypeScript 6 and raise the minimum Node.js version to 22.
-
-  All packages now build against `typescript@^6.0.3` and declare `engines.node >= 22`. Internal tooling (`ts-json-schema-generator`, `zod-to-ts`) was bumped to TypeScript 6-compatible releases.
-
-- Updated dependencies [41ce2cb]
-  - @pikku/core@0.12.44
-
-## 0.12.0
-
-## 0.12.1
-
-### Patch Changes
-
-- e04531f: Code quality improvements: resolve oxlint warnings and apply autofixes across the codebase (unused bindings, unnecessary constructors, prefer `const` over `let`, etc.). No behaviour changes.
-- Updated dependencies [62a8725]
-- Updated dependencies [a3bdb0d]
-- Updated dependencies [e0349ff]
-- Updated dependencies [62a8725]
-- Updated dependencies [e04531f]
-- Updated dependencies [62a8725]
-- Updated dependencies [a83efb8]
-- Updated dependencies [8eed717]
-- Updated dependencies [62a8725]
-- Updated dependencies [62a8725]
-- Updated dependencies [62a8725]
-  - @pikku/core@0.12.1
-
-- Updated dependencies
-
-## 0.11.0
-
-## 0.11.1
-
-### Patch Changes
-
-- 4b811db: chore: updating all dependencies
-- Updated dependencies [4b811db]
-- Updated dependencies [e12a00c]
-- Updated dependencies [4579434]
-- Updated dependencies [28aeb7f]
-- Updated dependencies [ce902b1]
-- Updated dependencies [06e1a31]
-  - @pikku/core@0.11.1
-
-### Minor Changes
-
-- Workflow support
-
-# @pikku/azure-functions
-
-## 0.10.0
-
-This release includes significant improvements across the framework including tree-shaking support, middleware/permission factories, enhanced CLI functionality, improved TypeScript type safety, and comprehensive test strategies.
-
-For complete details, see https://pikku.dev/changelogs/0_10_0.md
-
-## 0.9.3-next.0
-
-### Patch Changes
-
-- Updated dependencies
-  - @pikku/core@0.9.12-next.0
-
-## 0.9.2
-
-### Patch Changes
-
-- a5905a9: chore: updating all dependencies
-- Updated dependencies [1256238]
-- Updated dependencies [6cf8efd]
-- Updated dependencies [d3a9a09]
-- Updated dependencies [840e078]
-- Updated dependencies [667d23c]
-- Updated dependencies [a5905a9]
-  - @pikku/core@0.9.2
-
-## 0.9.1
-
-### Patch Changes
-
-- fdb1593: core: bumping everything with a patch to sync up the major release inconsistencies in dependencies
-- Updated dependencies [fdb1593]
-  - @pikku/core@0.9.1
-
-## 0.9.0
-
-### Breaking Changes
-
-- Normalized all transports to use "wirings" instead of events/routes/transports for consistency across the framework
-
-## 0.8.0
-
-- Updating to match remaining packages
-
-## 0.7.0
-
-- Updating to match remaining packages
-
-## 0.6.1
-
-### Patch Changes
-
-- 0a92fa7: refactor: pulling schema into seperate package since ajv doesnt work on cloudflare (also keeps bundle size small!)
-- Updated dependencies [0a92fa7]
-  - @pikku/core@0.6.7
-
-## 0.6
-
-Marking a major release to include channels and scheduled tasks
-
-## 0.5.4
-
-### Patch Changes
-
-- 886a2fb: refactor: moving singletons (like routes and channels) to global to avoid nodemodule overrides
-- Updated dependencies [a768bad]
-- Updated dependencies [886a2fb]
-- Updated dependencies [886a2fb]
-  - @pikku/core@0.5.28
-
-## 0.5.3
-
-### Patch Changes
-
-- 0f96787: refactor: dropping cjs support
-- 64e4a1e: refactor: seperating core into cleaner sub-packages
-- c23524a: refactor: bump to versions to ensure correct package usage
-- Updated dependencies [0f96787]
-- Updated dependencies [64e4a1e]
-- Updated dependencies [c23524a]
-  - @pikku/core@0.5.25
-
-## 0.5.2
-
-### Patch Changes
-
-- bba25cc: chore: updating all packages to reflect major changes
-- Updated dependencies [bba25cc]
-- Updated dependencies [9deb482]
-- Updated dependencies [ee0c6ea]
-  - @pikku/core@0.5.24
-
-## 0.5.1
-
-### Patch Changes
-
-- d58c440: refactor: making http requests explicit to support other types
-- b01ecbf: fix: adding index file
-- Updated dependencies [cbcc75b]
-- Updated dependencies [d58c440]
-- Updated dependencies [11c50d4]
-  - @pikku/core@0.5.19

package/run-tests.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-
-# Enable nullglob to handle cases where no files match the pattern
-shopt -s nullglob
-
-# Initialize variables for options
-watch_mode=false
-coverage_mode=false
-
-# Parse command-line options
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --watch)
-      watch_mode=true
-      shift
-      ;;
-    --coverage)
-      coverage_mode=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Define the pattern to match your test files
-pattern="src/*.test.ts"
-
-# Expand the pattern into an array of files
-files=($(find src -type f -name "*.test.ts"))
-
-# Check if any files matched the pattern
-if [ ${#files[@]} -eq 0 ]; then
-  echo "No test files found matching pattern: $pattern"
-  exit 0
-fi
-
-# Construct the node command
-node_cmd=(node --import tsx --test)
-
-# Append options based on flags
-if [ "$watch_mode" = true ]; then
-  node_cmd+=(--watch)
-fi
-
-if [ "$coverage_mode" = true ]; then
-  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
-fi
-
-# Execute the node command with the expanded list of files
-"${node_cmd[@]}" "${files[@]}"

package/src/azure-deployment-service.ts

@@ -1,75 +0,0 @@
-/**
- * Azure Functions deployment service — routes remote() calls via HTTP.
- *
- * When a gateway (agent, MCP, channel, workflow orchestrator) calls
- * remote('funcName'), this service dispatches to the function's
- * Azure Function via HTTP. Uses the function's URL endpoint.
- *
- * Session propagation uses the existing pikkuRemoteAuthMiddleware:
- * JWT signed with PIKKU_REMOTE_SECRET, session encrypted in payload.
- */
-
-import type { DeploymentService, DeploymentConfig } from '@pikku/core/services'
-import type { JWTService } from '@pikku/core/services'
-import type { SecretService } from '@pikku/core/services'
-import { buildRemoteHeaders } from '@pikku/core/remote'
-
-export class AzureDeploymentService implements DeploymentService {
-  private bindings: Map<string, string>
-
-  constructor(
-    private jwt: JWTService | undefined,
-    private secrets: SecretService,
-    functionBindings: Record<string, string>
-  ) {
-    this.bindings = new Map(Object.entries(functionBindings))
-  }
-
-  async init(): Promise<void> {}
-  async start(_config: DeploymentConfig): Promise<void> {}
-  async stop(): Promise<void> {}
-
-  async invoke(
-    funcName: string,
-    data: unknown,
-    session?: unknown,
-    traceId?: string
-  ): Promise<unknown> {
-    const functionUrl = this.bindings.get(funcName)
-    if (!functionUrl) {
-      throw new Error(
-        `No Azure Function binding for function '${funcName}'. ` +
-          `Available bindings: ${[...this.bindings.keys()].join(', ')}`
-      )
-    }
-
-    const headers = await buildRemoteHeaders(
-      this.jwt,
-      this.secrets,
-      funcName,
-      session,
-      traceId
-    )
-
-    const url = `${functionUrl}/remote/rpc/${encodeURIComponent(funcName)}`
-    const response = await fetch(url, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ data }),
-    })
-
-    if (!response.ok) {
-      let errorBody: string
-      try {
-        errorBody = JSON.stringify(await response.json())
-      } catch {
-        errorBody = await response.text()
-      }
-      throw new Error(
-        `Remote RPC call to '${funcName}' failed: ${response.status} ${response.statusText}. ${errorBody}`
-      )
-    }
-
-    return response.json()
-  }
-}

package/src/azure-queue-service.ts

@@ -1,91 +0,0 @@
-/**
- * Azure Storage Queue implementation of QueueService (producer side).
- *
- * Sends messages to Azure Storage Queues. Queue URLs are resolved from
- * environment variables following the convention:
- * AZURE_QUEUE_NAME_<SCREAMING_SNAKE> (queue name) with the connection
- * string from AzureWebJobsStorage.
- */
-
-import { QueueServiceClient } from '@azure/storage-queue'
-import type { QueueClient } from '@azure/storage-queue'
-import type { QueueService, QueueJob } from '@pikku/core/queue'
-import type { JobOptions } from '@pikku/core/queue'
-
-export class AzureQueueService implements QueueService {
-  readonly supportsResults = false
-  private queueServiceClient: QueueServiceClient
-  private queueClients = new Map<string, QueueClient>()
-
-  constructor(connectionString?: string) {
-    const connStr = connectionString ?? process.env.AzureWebJobsStorage
-    if (!connStr) {
-      throw new Error(
-        'Azure Queue connection string not provided; supply connectionString or set AzureWebJobsStorage'
-      )
-    }
-    this.queueServiceClient = QueueServiceClient.fromConnectionString(connStr)
-  }
-
-  async add<T>(
-    queueName: string,
-    data: T,
-    options?: JobOptions
-  ): Promise<string> {
-    const client = this.getQueueClient(queueName)
-    const messageId = crypto.randomUUID()
-
-    const message = {
-      id: messageId,
-      queueName,
-      data,
-      pikkuUserId: options?.pikkuUserId,
-    }
-
-    // Azure Storage Queue messages must be base64-encoded strings
-    const encoded = Buffer.from(JSON.stringify(message)).toString('base64')
-
-    const visibilityTimeout = options?.delay
-      ? Math.min(Math.ceil(options.delay / 1000), 604800) // max 7 days
-      : undefined
-
-    await client.sendMessage(encoded, { visibilityTimeout })
-    return messageId
-  }
-
-  async getJob<T, R>(
-    _queueName: string,
-    _jobId: string
-  ): Promise<QueueJob<T, R> | null> {
-    throw new Error(
-      'AzureQueueService does not support getJob(). ' +
-        'Azure Storage Queues are fire-and-forget. ' +
-        'Use BullMQ or PgBoss if you need job result tracking.'
-    )
-  }
-
-  private getQueueClient(queueName: string): QueueClient {
-    if (!this.queueClients.has(queueName)) {
-      const resolvedName = this.resolveQueueName(queueName)
-      const client = this.queueServiceClient.getQueueClient(resolvedName)
-      this.queueClients.set(queueName, client)
-    }
-    return this.queueClients.get(queueName)!
-  }
-
-  /**
-   * Resolves the Azure queue name. Checks env var
-   * AZURE_QUEUE_NAME_<SCREAMING_SNAKE> first, falls back to the name as-is.
-   */
-  private resolveQueueName(queueName: string): string {
-    const envKey = `AZURE_QUEUE_NAME_${toScreamingSnake(queueName)}`
-    return process.env[envKey] ?? queueName
-  }
-}
-
-function toScreamingSnake(name: string): string {
-  return name
-    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-    .replace(/-/g, '_')
-    .toUpperCase()
-}

package/src/handler-factories.ts

@@ -1,205 +0,0 @@
-/**
- * Azure Functions handler factories — mirrors Lambda/CF handler factories.
- *
- * Creates handlers for Azure Functions v4 programming model:
- * - HTTP triggers (HttpRequest → HttpResponseInit)
- * - Storage Queue triggers (QueueItem → void)
- * - Timer triggers (Timer → void)
- *
- * Services are cached across invocations within the same function app instance.
- */
-
-import { LocalVariablesService, LocalSecretService } from '@pikku/core/services'
-import type { CoreSingletonServices } from '@pikku/core/types'
-import { PikkuFetchHTTPResponse, fetchData } from '@pikku/core/http'
-import { runQueueJob } from '@pikku/core/queue'
-import type { QueueJob, QueueJobStatus } from '@pikku/core/queue'
-import { runScheduledTask } from '@pikku/core/scheduler'
-import { getScheduledTasks } from '@pikku/core/scheduler'
-import type {
-  HttpRequest,
-  HttpResponseInit,
-  InvocationContext,
-  Timer,
-} from '@azure/functions'
-
-export interface AzureServiceFactories {
-  createConfig: (
-    variables: LocalVariablesService,
-    ...args: unknown[]
-  ) => Promise<unknown>
-  createSingletonServices: (
-    config: unknown,
-    existingServices?: Partial<Record<string, unknown>>
-  ) => Promise<CoreSingletonServices>
-  createPlatformServices?: () =>
-    Record<string, unknown> | Promise<Record<string, unknown>>
-}
-
-let cachedServices: CoreSingletonServices | null = null
-
-async function setupServices(
-  factories: AzureServiceFactories
-): Promise<CoreSingletonServices> {
-  if (cachedServices) return cachedServices
-  const variables = new LocalVariablesService(
-    process.env as Record<string, string | undefined>
-  )
-  const config = await factories.createConfig(variables)
-  const secrets = new LocalSecretService(variables)
-
-  const platformServices = factories.createPlatformServices
-    ? await factories.createPlatformServices()
-    : {}
-
-  cachedServices = await factories.createSingletonServices(config, {
-    variables,
-    secrets,
-    ...platformServices,
-  })
-  return cachedServices
-}
-
-/**
- * Creates combined Azure Function handlers based on which handler types
- * the unit needs. Returns an object with named handler functions that
- * the entry file registers via app.http(), app.storageQueue(), app.timer().
- */
-export function createAzureHandler(
-  factories: AzureServiceFactories,
-  handlerTypes: string[]
-) {
-  const result: Record<string, unknown> = {}
-
-  if (handlerTypes.includes('fetch')) {
-    result.http = async (
-      request: HttpRequest,
-      _context: InvocationContext
-    ): Promise<HttpResponseInit> => {
-      await setupServices(factories)
-
-      // Convert Azure HttpRequest to standard Request
-      const body =
-        request.method !== 'GET' && request.method !== 'HEAD'
-          ? await request.text()
-          : undefined
-      const webRequest = new Request(request.url, {
-        method: request.method,
-        headers: Object.fromEntries(request.headers.entries()),
-        body,
-      })
-
-      const response = new PikkuFetchHTTPResponse()
-      try {
-        await fetchData(webRequest, response)
-      } catch (err) {
-        console.error('Azure HTTP handler: fetchData error', err)
-      }
-
-      const fetchResponse = response.toResponse()
-      const headers: Record<string, string> = {}
-      fetchResponse.headers.forEach((value, key) => {
-        headers[key] = value
-      })
-
-      return {
-        status: fetchResponse.status,
-        headers,
-        body: await fetchResponse.text(),
-      }
-    }
-  }
-
-  if (handlerTypes.includes('queue')) {
-    result.queue = async (
-      queueItem: unknown,
-      context: InvocationContext
-    ): Promise<void> => {
-      await setupServices(factories)
-
-      let data: Record<string, unknown>
-      if (typeof queueItem === 'string') {
-        try {
-          data = JSON.parse(queueItem)
-        } catch {
-          data = { body: queueItem }
-        }
-      } else {
-        data = queueItem as Record<string, unknown>
-      }
-
-      const queueName =
-        (data.queueName as string) ??
-        context.triggerMetadata?.queueTrigger ??
-        'unknown'
-
-      const job: QueueJob = {
-        queueName,
-        data: data.data ?? data,
-        id: context.invocationId,
-        status: async () => 'active' as QueueJobStatus,
-        metadata: () => ({
-          processedAt: new Date(),
-          attemptsMade: (context.triggerMetadata?.dequeueCount as number) ?? 0,
-          maxAttempts: undefined,
-          result: undefined,
-          progress: 0,
-          createdAt: new Date(),
-          completedAt: undefined,
-          failedAt: undefined,
-          error: undefined,
-        }),
-        waitForCompletion: async () => {
-          throw new Error(
-            'Azure Storage Queues do not support waitForCompletion'
-          )
-        },
-      }
-
-      await runQueueJob({ job })
-    }
-  }
-
-  if (handlerTypes.includes('scheduled')) {
-    result.timer = async (
-      _timer: Timer,
-      _context: InvocationContext
-    ): Promise<void> => {
-      await setupServices(factories)
-      const traceId = `cron-${crypto.randomUUID()}`
-      const scheduledTasks = getScheduledTasks()
-      for (const [name] of scheduledTasks) {
-        await runScheduledTask({ name, traceId })
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Creates an Azure Function handler with an HTTP trigger for gateway units.
- */
-export function createAzureWorkerHandler(factories: AzureServiceFactories) {
-  const handlers = createAzureHandler(factories, ['fetch'])
-  return handlers
-}
-
-/**
- * Creates Azure Function handlers for WebSocket channel units.
- * Uses HTTP negotiation endpoint for Azure Web PubSub.
- */
-export function createAzureWebSocketHandler(_factories: AzureServiceFactories) {
-  return {
-    async negotiate(
-      _request: HttpRequest,
-      _context: InvocationContext
-    ): Promise<HttpResponseInit> {
-      // Web PubSub negotiation — to be implemented with @azure/web-pubsub
-      return {
-        status: 501,
-        body: 'WebSocket via Azure Web PubSub not yet implemented',
-      }
-    },
-  }
-}

package/src/index.test.ts

@@ -1,13 +0,0 @@
-import assert from 'node:assert/strict'
-import { describe, test } from 'node:test'
-
-import * as azureFunctions from './index.js'
-
-describe('@pikku/azure-functions', () => {
-  test('exports the azure runtime API', () => {
-    assert.equal(typeof azureFunctions.createAzureHandler, 'function')
-    assert.equal(typeof azureFunctions.AzureDeploymentService, 'function')
-    assert.equal(typeof azureFunctions.AzureQueueService, 'function')
-    assert.equal(typeof azureFunctions.AzInvocationLogger, 'function')
-  })
-})

package/src/index.ts

@@ -1,9 +0,0 @@
-export * from './pikku-az-functions-logger.js'
-export * from './pikku-az-timer-request.js'
-export {
-  createAzureHandler,
-  createAzureWorkerHandler,
-  createAzureWebSocketHandler,
-} from './handler-factories.js'
-export { AzureQueueService } from './azure-queue-service.js'
-export { AzureDeploymentService } from './azure-deployment-service.js'

package/src/pikku-az-functions-logger.ts

@@ -1,48 +0,0 @@
-import type { InvocationContext } from '@azure/functions'
-import type { Logger, LogLevel } from '@pikku/core/services'
-import type { Safe } from '@pikku/core/classification'
-
-export class AzInvocationLogger implements Logger {
-  // private logLevel: LogLevel = LogLevel.info
-
-  constructor(private context: InvocationContext) {}
-
-  public info<M extends string | Record<string, any>, A extends unknown[]>(
-    messageOrObj: Safe<M>,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void {
-    this.context.info(messageOrObj as any, ...meta)
-  }
-
-  public warn<M extends string | Record<string, any>, A extends unknown[]>(
-    messageOrObj: Safe<M>,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void {
-    this.context.warn(messageOrObj as any, ...meta)
-  }
-
-  public error<
-    M extends string | Record<string, any> | Error,
-    A extends unknown[],
-  >(messageOrObj: Safe<M>, ...meta: { [K in keyof A]: Safe<A[K]> }): void {
-    this.context.error(messageOrObj as any, ...meta)
-  }
-
-  public debug<A extends unknown[]>(
-    message: string,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void {
-    this.context.debug(message, ...meta)
-  }
-
-  public trace<A extends unknown[]>(
-    message: string,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void {
-    this.context.trace(message, ...meta)
-  }
-
-  public setLevel(level: LogLevel): void {
-    // this.logLevel = level
-  }
-}

package/src/pikku-az-functions-logger.type.test.ts

@@ -1,18 +0,0 @@
-import { createSecretValue } from '@pikku/core/classification'
-import type { AzInvocationLogger } from './pikku-az-functions-logger.js'
-
-// A concrete logger must not be a way around the `Logger` guard.
-const _assertions = (logger: AzInvocationLogger) => {
-  const secret = createSecretValue('sk-live-DEADBEEF')
-
-  // @ts-expect-error a secret cannot be logged
-  logger.info(secret)
-  // @ts-expect-error nor nested in the message
-  logger.info({ token: secret })
-  // @ts-expect-error nor in the metadata
-  logger.warn('using', { token: secret })
-
-  logger.info('fine')
-  logger.info({ count: 1 })
-}
-void _assertions

package/src/pikku-az-timer-request.ts

@@ -1,8 +0,0 @@
-import type { InvocationContext } from '@azure/functions'
-import { PikkuRequest } from '@pikku/core/function'
-
-export class PikkuAZTimerRequest<In = any> extends PikkuRequest<In> {
-  constructor(_context: InvocationContext, data: In) {
-    super(data)
-  }
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "module": "Node18",
-    "outDir": "dist",
-    "target": "esnext",
-    "declaration": true
-  },
-  "include": ["bin/**/*.ts", "src/**/*.ts"],
-  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
-  "references": [
-    {
-      "path": "../../core/tsconfig.json"
-    }
-  ]
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/azure-deployment-service.ts","./src/azure-queue-service.ts","./src/handler-factories.ts","./src/index.ts","./src/pikku-az-functions-logger.ts","./src/pikku-az-timer-request.ts"],"version":"6.0.3"}

package/tsconfig.type-tests.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "composite": false,
-    "declaration": false,
-    "declarationMap": false
-  },
-  "files": ["src/pikku-az-functions-logger.type.test.ts"]
-}