@camstack/server 1.1.71 → 1.1.73

package/dist/api/core/cap-providers.js

@@ -1136,17 +1136,6 @@ function buildAddonsProvider(ar, ps, ls, moleculer, configService, ctx) {
             (0, collection_preference_js_1.persistCollectionDisabled)(configService, input.capName, updated?.disabledProviders ?? []);
             return { success: true };
         },
-        updateFrameworkPackage: async (input) => ps.updateFrameworkPackage({
-            packageName: input.packageName,
-            ...(input.version !== undefined ? { version: input.version } : {}),
-            ...(ctx.user?.username !== undefined
-                ? { requestedBy: ctx.user.username }
-                : ctx.user?.id !== undefined
-                    ? { requestedBy: ctx.user.id }
-                    : {}),
-            ...(input.deferRestart !== undefined ? { deferRestart: input.deferRestart } : {}),
-            runner: lifecycleRunner,
-        }),
         getVersions: async (input) => ps.getPackageVersions(input.name),
         restartAddon: async (input) => ar.restartAddon(input.addonId),
         retryLoad: async (input) => {

package/dist/api/core/lifecycle-job-runner.js

@@ -75,8 +75,6 @@ function createLifecycleJobRunner(deps) {
         applyAddonUpdate: deps.applyAddonUpdate,
         emit: deps.emit,
         now: nowFn,
-        stageFramework: deps.stageFramework,
-        requestFrameworkSwap: deps.requestFrameworkSwap,
     });
     /**
      * Set of jobIds currently executing — used to guard cancellation.

package/dist/api/trpc/cap-mount-helpers.js

@@ -48,13 +48,25 @@ function requireDeviceScoped(registry, capName) {
                         message: `${String(capName)}.${prop}: input must carry numeric "deviceId"`,
                     });
                 }
-                const native = registry.getNativeProvider(capName, deviceId);
-                if (!native) {
-                    // No native provider. For `getStatus`, the device may still have a
-                    // SYNTHESIZED status from device-links (battery/consumables wired
-                    // from sibling sensors). Consult the resolver with a null base
-                    // (the synthesize path) before failing — it returns null when the
-                    // device has no links for this cap, preserving today's error.
+                // Fast path (unchanged): a per-device native provider registered for
+                // the exact (cap, deviceId) pair.
+                let provider = registry.getNativeProvider(capName, deviceId);
+                // D13 fallback: a device cap may be served by a WRAPPER / system
+                // provider bound to this device (e.g. the `virtual-doorbell` builtin
+                // registers a SINGLETON wrapper — no native). Consult the unified
+                // per-device resolver `getProviderForDevice` (native OR device-bound
+                // system) BEFORE the synthesize fallback + the final throw. This
+                // never runs when a native was found, keeping the fast path intact.
+                if (!provider) {
+                    provider = registry.getProviderForDevice(capName, deviceId);
+                }
+                if (!provider) {
+                    // No native and no device-bound provider. For `getStatus`, the
+                    // device may still have a SYNTHESIZED status from device-links
+                    // (battery/consumables wired from sibling sensors). Consult the
+                    // resolver with a null base (the synthesize path) before failing —
+                    // it returns null when the device has no links for this cap,
+                    // preserving today's error.
                     if (prop === 'getStatus') {
                         const deviceManager = registry.getSingleton('device-manager');
                         const synthesized = await deviceManager?.resolveLinkedStatus?.({
@@ -70,14 +82,14 @@ function requireDeviceScoped(registry, capName) {
                         message: `Capability "${String(capName)}" not registered for device ${deviceId}`,
                     });
                 }
-                const fn = native[prop];
+                const fn = provider[prop];
                 if (typeof fn !== 'function') {
                     throw new server_1.TRPCError({
                         code: 'NOT_IMPLEMENTED',
                         message: `Capability "${String(capName)}" provider for device ${deviceId} does not implement "${prop}"`,
                     });
                 }
-                const result = await fn.call(native, input);
+                const result = await fn.call(provider, input);
                 // Device-property-wiring overlay (read-time): only `getStatus`, and only
                 // when the device has links for this cap (resolveLinkedStatus returns
                 // null otherwise → base result untouched). One in-process singleton hop.

package/dist/api/trpc/generated-cap-routers.js

@@ -605,14 +605,6 @@ function createCapRouter_addons(getProvider, _createRemoteProxy) {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
             return p.setCapabilityProviderEnabled(input);
         }),
-        updateFrameworkPackage: trpc_middleware_js_1.adminProcedure
-            .input(types_10.addonsCapability.methods.updateFrameworkPackage.input.loose())
-            .output(types_10.addonsCapability.methods.updateFrameworkPackage.output)
-            .mutation(async ({ input, ctx }) => {
-            const p = requireCapProvider('addons', () => getProvider(ctx));
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-            return p.updateFrameworkPackage(input);
-        }),
         getVersions: trpc_middleware_js_1.protectedProcedure
             .input(types_10.addonsCapability.methods.getVersions.input.loose())
             .output(types_10.addonsCapability.methods.getVersions.output)

package/dist/api/trpc/trpc.router.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enrichInputWithUserAgent = enrichInputWithUserAgent;
 exports.enrichInputWithRelayClass = enrichInputWithRelayClass;
+exports.enrichHintsWithClientClass = enrichHintsWithClientClass;
 exports.wrapWebrtcSessionProviderWithRelay = wrapWebrtcSessionProviderWithRelay;
 exports.buildAppRouter = buildAppRouter;
 const addon_settings_router_js_1 = require("../core/addon-settings.router.js");
@@ -87,6 +88,52 @@ function enrichInputWithRelayClass(input, clientClass) {
     const relayOnly = FORCE_RELAY_REMOTE ? (0, client_ip_js_1.deriveRelayOnly)(clientClass) : false;
     return { ...input, relayOnly };
 }
+/**
+ * Initial adaptive rung for a genuinely-REMOTE viewer.
+ *
+ * A `remote` (public / CGNAT-4G / internet) client cannot reliably receive the
+ * high tier's large keyframe over a lossy relay path — LAN can, which is why
+ * adaptive works on LAN but a remote adaptive viewer sees a permanent black
+ * frame (ICE/DTLS up, no decodable frame). So a remote adaptive session STARTS
+ * on the smallest tier; the broker's `AdaptiveController` upgrades from there
+ * once the link proves healthy. `lan` and `vpn` (Tailscale, direct overlay)
+ * keep the full-quality default and are never biased.
+ */
+const REMOTE_INITIAL_ADAPTIVE_TIER = 'low';
+/**
+ * Bias the INITIAL adaptive-tier selection for a genuinely-remote viewer by
+ * injecting a `prefersTier` hint the broker's `selectBestBroker` already
+ * honours. The hub is the only layer that knows the client's network class
+ * (the forked broker cannot see the HTTP request), so — exactly like
+ * `relayOnly` and the User-Agent — the class is read here and threaded down
+ * through the EXISTING `hints` cap field (no cap/schema change: `prefersTier`
+ * is already part of `webrtcClientHintsSchema`).
+ *
+ * Applied ONLY when:
+ *  - the client class is `remote` (lan/vpn keep the full-quality default), and
+ *  - the target is adaptive (`handleOffer` defaults an absent target to
+ *    adaptive; a pinned profile/cam-stream is the operator's explicit choice
+ *    and passes through untouched), and
+ *  - the caller did not already set `prefersTier` (no client does today, but
+ *    keep the trusted-injection rule symmetric with relayOnly/userAgent).
+ *
+ * Immutable — builds a NEW input (and a new `hints`), never mutates the
+ * caller's. On a downgrade re-offer the broker's controller-chosen tier intent
+ * overrides this hint, so a healthy remote session can still climb above `low`.
+ */
+function enrichHintsWithClientClass(input, clientClass) {
+    if (clientClass !== 'remote')
+        return input;
+    const isAdaptive = input.target === undefined || input.target.kind === 'adaptive';
+    if (!isAdaptive)
+        return input;
+    if (input.hints?.prefersTier !== undefined)
+        return input;
+    return {
+        ...input,
+        hints: { ...input.hints, prefersTier: REMOTE_INITIAL_ADAPTIVE_TIER },
+    };
+}
 /**
  * Per-request wrapper around the resolved `webrtc-session` broker singleton.
  *
@@ -125,8 +172,8 @@ function wrapWebrtcSessionProviderWithRelay(provider, ctx) {
     const clientClass = (0, client_ip_js_1.classifyClientRequest)(ctx.req);
     return {
         ...provider,
-        createSession: (input) => provider.createSession(enrichInputWithRelayClass(enrichInputWithUserAgent(input, userAgent), clientClass)),
-        handleOffer: (input) => provider.handleOffer(enrichInputWithRelayClass(enrichInputWithUserAgent(input, userAgent), clientClass)),
+        createSession: (input) => provider.createSession(enrichHintsWithClientClass(enrichInputWithRelayClass(enrichInputWithUserAgent(input, userAgent), clientClass), clientClass)),
+        handleOffer: (input) => provider.handleOffer(enrichHintsWithClientClass(enrichInputWithRelayClass(enrichInputWithUserAgent(input, userAgent), clientClass), clientClass)),
     };
 }
 /**

package/dist/boot/post-boot.service.js

@@ -4,7 +4,6 @@ exports.PostBootService = void 0;
 const node_crypto_1 = require("node:crypto");
 const system_1 = require("@camstack/system");
 const types_1 = require("@camstack/types");
-const resume_framework_swap_js_1 = require("./resume-framework-swap.js");
 const reconcile_lifecycle_jobs_js_1 = require("./reconcile-lifecycle-jobs.js");
 class PostBootService {
     eventBus;
@@ -57,24 +56,12 @@ class PostBootService {
         // restart, …). `readPendingRestart` clears the marker atomically so
         // we never re-fire on a crash-loop boot.
         this.emitRestartCompletedIfPending(dataPath);
-        // If a framework swap was applied on the previous boot and left a
-        // `.framework-swap-confirm.json` marker, mark the journal job done and
-        // delete the marker + backups now that the hub is healthy.  This also
-        // disarms the crash-loop rollback (the NEXT boot won't roll back a
-        // healthy update).
-        await this.resumeFrameworkSwapIfPending(dataPath);
-        // Then re-drive every other non-terminal lifecycle job (addon task phases)
-        // from its on-disk checkpoint. Order matters: framework resume FIRST (marks
-        // the framework task `applied`→`done`), THEN addon reconcile (which leaves
-        // framework tasks untouched).
+        // Re-drive every non-terminal lifecycle job (addon task phases) from its
+        // on-disk checkpoint. Framework tasks are no longer applied by the engine
+        // (single-copy collapse — framework updates ship via applyServerUpdate);
+        // any stray framework task is skipped during reconcile.
         await this.reconcileLifecycleJobsIfAny();
     }
-    async resumeFrameworkSwapIfPending(dataDir) {
-        const result = await (0, resume_framework_swap_js_1.resumeFrameworkSwapJob)(dataDir);
-        if (result.resumed) {
-            this.logger.info('Framework update completed', { meta: { jobId: result.jobId } });
-        }
-    }
     async reconcileLifecycleJobsIfAny() {
         const { resumed, failed } = await (0, reconcile_lifecycle_jobs_js_1.reconcileLifecycleJobsAtBoot)();
         if (resumed + failed > 0) {

package/dist/boot/reconcile-lifecycle-jobs.js

@@ -8,12 +8,13 @@
  * resumes from its checkpoint (reusing a still-valid `stagedPath` or
  * re-fetching, then applying).
  *
- * Best-effort, mirrors `resume-framework-swap.ts`: this NEVER throws — any error
- * (runner not initialized, journal corruption, …) is swallowed and reported as
- * `{ resumed: 0, failed: 0 }` so the post-boot path can never crash the hub.
+ * Best-effort: this NEVER throws — any error (runner not initialized, journal
+ * corruption, …) is swallowed and reported as `{ resumed: 0, failed: 0 }` so the
+ * post-boot path can never crash the hub.
  *
- * Ordering note: the framework `applied`→`done` resume (`resumeFrameworkSwapJob`)
- * MUST run BEFORE this — reconcile deliberately leaves framework tasks untouched.
+ * Framework tasks are no longer applied by the engine (single-copy collapse —
+ * framework updates ship via `applyServerUpdate`); any stray non-terminal
+ * framework task is marked `skipped` during reconcile so the job can finalize.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reconcileLifecycleJobsAtBoot = reconcileLifecycleJobsAtBoot;