@aglyn/plugins-marketplace 1.0.0-beta.143

package/src/lib/server/update-artifact.js

@@ -0,0 +1,569 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { createResourceUid, decodeStoredNodes, encodeStoredNodes, newResourceScopeFields, ORG_SCOPE_TOKEN } from "@aglyn/aglyn/server";
+import { applyArtifactUpdate, planArtifactUpdate, summarizeSchemaChange } from "../model/artifact-merge.js";
+import { ARTIFACT_BASE_COLLECTION } from "@aglyn/aglyn/app-utils/marketplace-provenance";
+import { firebaseAdmin, getOrgForHost } from "@aglyn/tenant-data-admin";
+import { resolveOrgPermissions } from "@aglyn/tenant-runtime/org-permissions";
+import { listingArtifactType, resolveInstalledDatasetSchema } from "../model/marketplace.js";
+import { readPublishedProps } from "../model/marketplace-props.js";
+import { recordInstallProvenance } from "./provenance.js";
+import { canActAsPublisher } from "./publisher-profile.js";
+import { requirePurchase } from "./purchase-entitlement.js";
+import { recordVersionMove } from "./version-stats.js";
+const trimChanges = (changes)=>// The dialog lists changes; a 400-node tree that changed wholesale would
+    // otherwise ship its entire content twice through a JSON response.
+    changes.slice(0, 200);
+export const updateArtifactHandler = async (req, res)=>{
+    var _ref, _ref1, _req_headers_authorization;
+    var _req_body, _req_body1, _req_body2, _req_body3, _req_body4, _req_body5;
+    if (req.method !== 'POST') {
+        return res.status(405).json({
+            error: 'Method not allowed'
+        });
+    }
+    const listingId = String((_ref = (_req_body = req.body) == null ? void 0 : _req_body.listingId) != null ? _ref : '');
+    const hostId = String((_ref1 = (_req_body1 = req.body) == null ? void 0 : _req_body1.hostId) != null ? _ref1 : '');
+    const action = ((_req_body2 = req.body) == null ? void 0 : _req_body2.action) === 'apply' ? 'apply' : 'preview';
+    const mode = ((_req_body3 = req.body) == null ? void 0 : _req_body3.mode) === 'copy' ? 'copy' : 'merge';
+    const takePaths = Array.isArray((_req_body4 = req.body) == null ? void 0 : _req_body4.takePaths) ? req.body.takePaths.map((path)=>String(path)) : [];
+    const confirmDestructive = Boolean((_req_body5 = req.body) == null ? void 0 : _req_body5.confirmDestructive);
+    if (!listingId || !hostId) {
+        return res.status(400).json({
+            error: 'Missing listingId or hostId'
+        });
+    }
+    const authorization = String((_req_headers_authorization = req.headers.authorization) != null ? _req_headers_authorization : '');
+    const idToken = authorization.startsWith('Bearer ') ? authorization.slice('Bearer '.length) : undefined;
+    if (!idToken) return res.status(401).json({
+        error: 'Unauthenticated'
+    });
+    try {
+        var _listing_priceUsd, _ref2, _data, _ref3, _listing_displayName, _listing_profileId, _listing_latestVersion, _listing_latestVersion1;
+        var _this;
+        const decoded = await firebaseAdmin.app().auth().verifyIdToken(idToken);
+        // The same gate installing uses: taking a new version of something is
+        // installing it, and a role that cannot install must not be able to
+        // rewrite an installed artifact through a different door.
+        const membership = await resolveOrgPermissions(decoded.uid, {
+            hostId
+        });
+        if (!membership.permissions.installPlugins) {
+            return res.status(403).json({
+                error: 'Your organization role does not allow installing from the marketplace'
+            });
+        }
+        const firestore = firebaseAdmin.app().firestore();
+        const hostRef = firestore.collection('hosts').doc(hostId);
+        const hostSnapshot = await hostRef.get();
+        if (!hostSnapshot.exists) {
+            return res.status(404).json({
+                error: 'Unknown site'
+            });
+        }
+        const listingRef = firestore.collection('marketplaceListings').doc(listingId);
+        const listingSnapshot = await listingRef.get();
+        const listing = listingSnapshot.data();
+        if (!listing || listing.deletedAt || // Staff takedown blocks new installs on EVERY artifact type
+        // (AGL-2290). AGL-948 extended takedown past plugins in the browse
+        // predicate and in `resolveMarketplacePluginVersion`, but the gate that
+        // decides whether content is HANDED OVER was only ever added to
+        // `install-plugin.ts`. So a component, theme, template, layout, email
+        // template or dataset schema that staff had taken down stayed
+        // installable by anyone holding its listing id — which makes takedown a
+        // suggestion for six of the seven artifact types.
+        //
+        // No owner exemption, matching `install-plugin.ts`: a takedown is a
+        // moderation decision about the artifact, not about who is asking.
+        listing.hiddenAt) {
+            return res.status(404).json({
+                error: 'Unknown listing'
+            });
+        }
+        // Taking a NEW version of a paid listing is buying content, and this
+        // route never asked whether the caller still owned it (AGL-1699). The
+        // install routes gate; this one only checked the org ROLE, so a buyer
+        // who was refunded — and even in `copy` mode, which installs the new
+        // version fresh — kept pulling every future paid release through here.
+        //
+        // Deliberately not a regression for anyone legitimate: a live purchase,
+        // a free listing, or the publisher's own listing all pass, and nobody
+        // without one of those could have had an installed copy to update.
+        // The `priceUsd > 0` test is out here rather than left to the helper so
+        // a free listing — most of them — does not pay for a publisher lookup.
+        const priceUsd = Number((_listing_priceUsd = listing.priceUsd) != null ? _listing_priceUsd : 0);
+        if (priceUsd > 0) {
+            var _membership_orgId;
+            const unpaid = await requirePurchase({
+                firestore,
+                buyerUid: decoded.uid,
+                // THE ORG THE LICENCE HAS TO COVER (AGL-2331). `membership.orgId` is
+                // resolved server-side from the caller's own membership by the
+                // permission gate above — never a request-body field — so this is the
+                // workspace the install actually lands in, and the only one a purchase
+                // can entitle here.
+                buyerOrgId: (_membership_orgId = membership.orgId) != null ? _membership_orgId : '',
+                listingId,
+                priceUsd,
+                ownsListing: await canActAsPublisher(firestore, decoded.uid, listing.profileId)
+            });
+            if (unpaid) return res.status(402).json(unpaid);
+        }
+        const artifactType = listingArtifactType(listing);
+        if (artifactType === 'plugin') {
+            // Plugins are pinned, not copied: an update moves a pointer at immutable
+            // bytes (AGL-1017) and has nothing to merge.
+            return res.status(400).json({
+                error: 'Plugins update by re-pinning — use the install route'
+            });
+        }
+        const versionSnapshot = await listingRef.collection('versions').doc(String(listing.latestVersion)).get();
+        if (!versionSnapshot.exists) {
+            return res.status(404).json({
+                error: 'Listing version missing'
+            });
+        }
+        const availableVersion = listing.latestVersion == null ? null : String(listing.latestVersion);
+        const orgId = (_ref2 = (_this = await getOrgForHost(hostId)) == null ? void 0 : _this.orgId) != null ? _ref2 : '';
+        /** The installed copy, the base it was installed from, and the offer. */ let target = null;
+        let incoming = null;
+        let installedVersion = null;
+        let baseSha = null;
+        let notMergeable;
+        let schemaSummary;
+        if (artifactType === 'component') {
+            var _ref4, _doc_get, _doc_get1;
+            const existing = await hostRef.collection('components').where('marketplace.listingId', '==', listingId).limit(1).get();
+            const doc = existing.docs.find((entry)=>!entry.get('deletedAt'));
+            if (!doc) return res.status(404).json({
+                error: 'Not installed on this site'
+            });
+            const version = versionSnapshot.data();
+            incoming = {
+                rootId: version.rootId,
+                nodes: version.nodes
+            };
+            installedVersion = String((_ref4 = (_doc_get = doc.get('installedFrom.version')) != null ? _doc_get : doc.get('marketplace.version')) != null ? _ref4 : '') || null;
+            baseSha = (_doc_get1 = doc.get('installedFrom.sha256')) != null ? _doc_get1 : null;
+            target = {
+                ref: doc.ref,
+                current: {
+                    rootId: doc.get('rootId'),
+                    // DECODED, because everything downstream compares by VALUE: the
+                    // divergence hash, and `planArtifactUpdate`'s three-way diff over
+                    // dotted paths like `nodes.abc123.props.title`. A stored `Bytes`
+                    // has no such paths, so the merge would see the whole tree as
+                    // removed and write an empty one back (AGL-1151).
+                    nodes: decodeStoredNodes(doc.get('nodes'))
+                },
+                write: (content)=>{
+                    var _ref, _ref1;
+                    return {
+                        rootId: (_ref = content == null ? void 0 : content.rootId) != null ? _ref : null,
+                        // Compressed at rest, like every other writer of this document.
+                        nodes: Buffer.from(encodeStoredNodes((_ref1 = content == null ? void 0 : content.nodes) != null ? _ref1 : {}))
+                    };
+                },
+                // Detaching keeps the customised component as an ordinary one: it stays
+                // on every page that uses it, and only stops being tracked against the
+                // listing — which is what makes "install as a new copy" non-destructive
+                // without leaving two documents claiming to be the same install.
+                detach: {
+                    marketplace: firebaseAdmin.firestore.FieldValue.delete(),
+                    detachedFrom: {
+                        listingId,
+                        version: installedVersion
+                    }
+                },
+                // `hosts/{hostId}/components` is private to its host; no scope.
+                forkScope: null,
+                props: readPublishedProps(version.props)
+            };
+        } else if (artifactType === 'layout') {
+            var _ref5, _doc_get2, _doc_get3;
+            const existing = await hostRef.collection('templates').where('source.listingId', '==', listingId).get();
+            const doc = existing.docs.find((entry)=>!entry.get('deletedAt') && entry.get('kind') === 'layout');
+            if (!doc) return res.status(404).json({
+                error: 'Not installed on this site'
+            });
+            const layout = versionSnapshot.get('layout');
+            incoming = {
+                rootId: layout == null ? void 0 : layout.rootId,
+                nodes: layout == null ? void 0 : layout.nodes
+            };
+            installedVersion = String((_ref5 = (_doc_get2 = doc.get('installedFrom.version')) != null ? _doc_get2 : doc.get('source.version')) != null ? _ref5 : '') || null;
+            baseSha = (_doc_get3 = doc.get('installedFrom.sha256')) != null ? _doc_get3 : null;
+            target = {
+                ref: doc.ref,
+                current: {
+                    rootId: doc.get('rootId'),
+                    // DECODED, because everything downstream compares by VALUE: the
+                    // divergence hash, and `planArtifactUpdate`'s three-way diff over
+                    // dotted paths like `nodes.abc123.props.title`. A stored `Bytes`
+                    // has no such paths, so the merge would see the whole tree as
+                    // removed and write an empty one back (AGL-1151).
+                    nodes: decodeStoredNodes(doc.get('nodes'))
+                },
+                write: (content)=>{
+                    var _ref, _ref1;
+                    return {
+                        rootId: (_ref = content == null ? void 0 : content.rootId) != null ? _ref : null,
+                        // Compressed at rest, like every other writer of this document.
+                        nodes: Buffer.from(encodeStoredNodes((_ref1 = content == null ? void 0 : content.nodes) != null ? _ref1 : {}))
+                    };
+                },
+                detach: {
+                    source: {
+                        type: 'workspace'
+                    },
+                    detachedFrom: {
+                        listingId,
+                        version: installedVersion
+                    }
+                },
+                // `hosts/{hostId}/templates` is private to its host; no scope.
+                forkScope: null,
+                props: readPublishedProps(layout == null ? void 0 : layout.props)
+            };
+        } else if (artifactType === 'datasetSchema') {
+            var _ref6, _doc_get4, _doc_get5, _doc_get6, _doc_get7, _ref7;
+            if (!orgId) {
+                return res.status(404).json({
+                    error: 'Site has no owning organization'
+                });
+            }
+            const orgRef = firestore.collection('orgs').doc(orgId);
+            const datasets = await orgRef.collection('datasets').get();
+            const doc = datasets.docs.find((entry)=>entry.get('source.listingId') === listingId && !entry.get('deletedAt'));
+            if (!doc) {
+                return res.status(404).json({
+                    error: 'Not installed in this organization'
+                });
+            }
+            // Relink the incoming schema onto THIS org's datasets exactly as install
+            // does — the base holds the relinked shape, so diffing the published one
+            // would report every reference field as a user edit.
+            const byLabel = {};
+            for (const entry of datasets.docs){
+                var _entry_get;
+                const label = String((_entry_get = entry.get('displayName')) != null ? _entry_get : '').toLowerCase();
+                if (label && !byLabel[label]) byLabel[label] = entry.id;
+            }
+            const { schema } = resolveInstalledDatasetSchema(versionSnapshot.get('datasetSchema'), byLabel);
+            incoming = schema;
+            installedVersion = String((_ref6 = (_doc_get4 = doc.get('installedFrom.version')) != null ? _doc_get4 : doc.get('source.version')) != null ? _ref6 : '') || null;
+            baseSha = (_doc_get5 = doc.get('installedFrom.sha256')) != null ? _doc_get5 : null;
+            const current = (_doc_get6 = doc.get('model')) != null ? _doc_get6 : {
+                order: (_doc_get7 = doc.get('fields')) != null ? _doc_get7 : [],
+                fields: {}
+            };
+            const summary = summarizeSchemaChange(current, schema);
+            // The count is read for the preview, not estimated: "3 fields will be
+            // removed" means nothing without "from 1,240 records".
+            const records = await doc.ref.collection('records').count().get().catch(()=>null);
+            schemaSummary = {
+                added: summary.added,
+                removed: summary.removed,
+                retyped: summary.retyped,
+                additiveOnly: summary.additiveOnly,
+                recordCount: (_ref7 = records == null ? void 0 : records.data().count) != null ? _ref7 : 0
+            };
+            const installedScope = doc.get('visibleTo');
+            target = {
+                ref: doc.ref,
+                current,
+                write: (content)=>{
+                    var _ref;
+                    return {
+                        model: content,
+                        // The v1 flat list the older editor still reads, kept in step.
+                        fields: (_ref = content == null ? void 0 : content.order) != null ? _ref : []
+                    };
+                },
+                // A fork INHERITS the copy it forked from, never a fresh default: a
+                // dataset restricted to one client's site must not reappear org-wide
+                // because somebody took a publisher update as a separate copy. An
+                // absent scope reads as org-wide everywhere else (`visibleToHost`),
+                // so it does here. A stored empty array — "visible to nobody" — is
+                // passed through and throws at the write rather than being widened,
+                // which is the right direction to fail in.
+                forkScope: Array.isArray(installedScope) ? installedScope : [
+                    ORG_SCOPE_TOKEN
+                ]
+            };
+        } else if (artifactType === 'theme') {
+            var _versionSnapshot_get, _hostSnapshot_get, _hostSnapshot_get1, _hostSnapshot_get2;
+            // A theme lives on the host document itself, so there is no artifact doc
+            // to look up and no "not installed on this site" — the site either runs
+            // this listing's theme or it does not.
+            if (hostSnapshot.get('themeInstalledFrom.listingId') !== listingId) {
+                return res.status(404).json({
+                    error: 'Not installed on this site'
+                });
+            }
+            incoming = (_versionSnapshot_get = versionSnapshot.get('theme')) != null ? _versionSnapshot_get : {};
+            installedVersion = String((_hostSnapshot_get = hostSnapshot.get('themeInstalledFrom.version')) != null ? _hostSnapshot_get : '') || null;
+            baseSha = (_hostSnapshot_get1 = hostSnapshot.get('themeInstalledFrom.sha256')) != null ? _hostSnapshot_get1 : null;
+            target = {
+                ref: hostRef,
+                current: (_hostSnapshot_get2 = hostSnapshot.get('theme')) != null ? _hostSnapshot_get2 : {},
+                write: (content)=>({
+                        theme: content != null ? content : {}
+                    }),
+                // No `detach`: a site has exactly one theme, so "install as a separate
+                // copy" has nowhere to put the second one. Merge is the only safe way
+                // to take a theme update, and the preview says so.
+                //
+                // A theme is a FIELD on the host document, so there is no document to
+                // scope even if it could fork.
+                forkScope: null
+            };
+        } else if (artifactType === 'template') {
+            // A published template bundle's screens carry no stable identity — only a
+            // displayName and a slug — so there is nothing to pair an old screen to a
+            // new one by. Any merge would be a guess dressed up as a diff.
+            notMergeable = 'Template bundles have no stable per-screen identity, so their screens ' + 'cannot be matched across versions. Installing the new version replaces ' + 'this bundle in your Templates library — pages you already created from ' + 'the old templates are ordinary screens and are untouched.';
+        } else if (artifactType === 'emailTemplate') {
+            // Already safe by construction: an email template installs as an inactive
+            // draft version, so taking a new one changes nothing that is being sent.
+            notMergeable = 'Email templates install as a draft version and never replace what your ' + 'site is sending. Add the new version as another draft, then activate ' + 'it when you are ready.';
+        }
+        if (notMergeable) {
+            const preview = {
+                artifactType,
+                installedVersion: null,
+                availableVersion,
+                mergeable: false,
+                reason: notMergeable,
+                safe: [],
+                kept: [],
+                conflicts: [],
+                unchanged: 0,
+                identical: false
+            };
+            return res.status(200).json({
+                preview
+            });
+        }
+        if (!target) {
+            return res.status(404).json({
+                error: 'Nothing installed to update'
+            });
+        }
+        const baseSnapshot = baseSha ? await firestore.collection(ARTIFACT_BASE_COLLECTION).doc(baseSha).get().catch(()=>null) : null;
+        const base = (baseSnapshot == null ? void 0 : baseSnapshot.exists) ? baseSnapshot.get('content') : undefined;
+        const mergeable = base !== undefined;
+        let plan = null;
+        if (mergeable) plan = planArtifactUpdate(base, target.current, incoming);
+        if (action === 'preview') {
+            var _ref8, _ref9, _ref10, _ref11, _ref12;
+            const preview = _extends({
+                artifactType,
+                installedVersion,
+                availableVersion,
+                mergeable
+            }, mergeable ? {} : {
+                reason: 'This was installed before update tracking recorded an ' + 'original, so there is no way to tell your changes from the ' + 'publisher’s. Installing the new version as a separate copy ' + 'keeps yours intact.'
+            }, {
+                safe: trimChanges((_ref8 = plan == null ? void 0 : plan.safe) != null ? _ref8 : []),
+                kept: trimChanges((_ref9 = plan == null ? void 0 : plan.kept) != null ? _ref9 : []),
+                conflicts: trimChanges((_ref10 = plan == null ? void 0 : plan.conflicts) != null ? _ref10 : []),
+                unchanged: (_ref11 = plan == null ? void 0 : plan.unchanged) != null ? _ref11 : 0,
+                identical: (_ref12 = plan == null ? void 0 : plan.identical) != null ? _ref12 : false
+            }, schemaSummary ? {
+                schema: schemaSummary
+            } : {});
+            return res.status(200).json({
+                preview
+            });
+        }
+        // ---- apply ----
+        const now = firebaseAdmin.firestore.FieldValue.serverTimestamp();
+        if (mode === 'merge') {
+            var _listing_profileId1, _listing_latestVersion2, _listing_latestVersion3;
+            if (!plan) {
+                return res.status(409).json({
+                    error: 'No original snapshot for this install — it can only be taken as a new copy'
+                });
+            }
+            // A schema change that removes or retypes a field reinterprets rows that
+            // already exist. It is applicable, but never without the caller having
+            // been told the count and said yes to it specifically.
+            if (schemaSummary && !schemaSummary.additiveOnly && !confirmDestructive) {
+                return res.status(409).json({
+                    error: `This update removes or retypes ${schemaSummary.removed.length + schemaSummary.retyped.length} field(s) on a dataset holding ${schemaSummary.recordCount} record(s).`,
+                    needsConfirmation: true,
+                    schema: schemaSummary
+                });
+            }
+            const merged = applyArtifactUpdate(plan, target.current, {
+                takePaths
+            });
+            const provenance = await recordInstallProvenance({
+                firestore,
+                listingId,
+                listing,
+                version: listing.latestVersion,
+                artifactType: artifactType,
+                // The base for NEXT time is the publisher's version, not the merged
+                // result: the base answers "what did the publisher ship", and seeding
+                // it with the merge would quietly launder this update's kept edits into
+                // the publisher's column, where the next update could take them away.
+                content: incoming
+            });
+            await target.ref.set(_extends({}, target.write(merged.content), target.props && {
+                props: target.props
+            }, artifactType === 'theme' ? {
+                themeInstalledFrom: provenance.installedFrom
+            } : _extends({
+                installedFrom: provenance.installedFrom
+            }, artifactType === 'component' ? {
+                marketplace: {
+                    listingId,
+                    profileId: (_listing_profileId1 = listing.profileId) != null ? _listing_profileId1 : null,
+                    version: (_listing_latestVersion2 = listing.latestVersion) != null ? _listing_latestVersion2 : null
+                }
+            } : {
+                source: {
+                    type: 'marketplace',
+                    listingId,
+                    version: (_listing_latestVersion3 = listing.latestVersion) != null ? _listing_latestVersion3 : null
+                }
+            }), {
+                updatedAt: now
+            }), {
+                merge: true
+            });
+            // Per-version tally (AGL-1036): this install just moved versions, which
+            // is the whole reason the per-version count exists.
+            await recordVersionMove({
+                firestore,
+                listingRef,
+                artifactType,
+                from: installedVersion,
+                to: availableVersion
+            });
+            return res.status(200).json({
+                updated: true,
+                mode,
+                version: availableVersion,
+                applied: merged.applied.length,
+                keptLocal: plan.kept.length,
+                skipped: merged.skipped,
+                baseStored: provenance.baseStored
+            });
+        }
+        // ---- copy ----
+        if (!target.detach) {
+            // Only types with a detachable link get a copy from here. A dataset's
+            // "new copy" is a whole new dataset, which consumes org quota and lands
+            // empty — exactly what the install route already does, with the quota
+            // check this one does not have.
+            //
+            // This return is also, today, the only thing keeping the fork below
+            // from creating an unstamped `orgs/{orgId}/datasets` document
+            // (AGL-1478): a dataset never reaches it because it has no `detach`.
+            // That is a guard by accident, three statements away from the write
+            // and phrased as a quota argument — give `datasetSchema` a `detach`
+            // for any reason and the scope hole opens with it. `Target.forkScope`
+            // is the guard that stays true whichever way this branch goes.
+            return res.status(400).json({
+                error: artifactType === 'theme' ? // copy. Merging keeps this site's edits; the way back to the
+                // previous theme is the install route's `revert`.
+                'A site has only one theme, so this update can only be merged. ' + 'Your edits to fields the publisher did not touch are kept.' : 'Install a fresh copy of this from the listing instead'
+            });
+        }
+        // The customised copy is detached rather than deleted or overwritten: it
+        // keeps working everywhere it is used, and only stops being the document
+        // this listing updates. Without the detach two documents would claim the
+        // same install and the next update would pick between them arbitrarily.
+        const provenance = await recordInstallProvenance({
+            firestore,
+            listingId,
+            listing,
+            version: listing.latestVersion,
+            artifactType: artifactType,
+            content: incoming
+        });
+        const batch = firestore.batch();
+        if (target.detach) {
+            batch.set(target.ref, _extends({}, target.detach, {
+                updatedAt: now
+            }), {
+                merge: true
+            });
+        }
+        const collectionRef = target.ref.parent;
+        const freshRef = collectionRef.doc(createResourceUid());
+        const carried = (_data = (await target.ref.get()).data()) != null ? _data : {};
+        batch.set(freshRef, _extends({}, carried.kind ? {
+            kind: carried.kind
+        } : {}, {
+            displayName: String((_ref3 = (_listing_displayName = listing.displayName) != null ? _listing_displayName : carried.displayName) != null ? _ref3 : 'Untitled')
+        }, listing.description ? {
+            description: listing.description
+        } : {}, newResourceScopeFields(target.forkScope), target.write(incoming), target.props ? {
+            props: target.props
+        } : Array.isArray(carried.props) ? {
+            props: carried.props
+        } : {}, artifactType === 'component' ? {
+            marketplace: {
+                listingId,
+                profileId: (_listing_profileId = listing.profileId) != null ? _listing_profileId : null,
+                version: (_listing_latestVersion = listing.latestVersion) != null ? _listing_latestVersion : null
+            }
+        } : {
+            source: {
+                type: 'marketplace',
+                listingId,
+                version: (_listing_latestVersion1 = listing.latestVersion) != null ? _listing_latestVersion1 : null
+            }
+        }, {
+            installedFrom: provenance.installedFrom,
+            deletedAt: null,
+            createdAt: now,
+            updatedAt: now
+        }));
+        await batch.commit();
+        // Per-version tally (AGL-1036). Still a move, not a second install: the
+        // detached copy stops being tracked against the listing, so the version it
+        // held is genuinely vacated.
+        await recordVersionMove({
+            firestore,
+            listingRef,
+            artifactType,
+            from: installedVersion,
+            to: availableVersion
+        });
+        return res.status(200).json({
+            updated: true,
+            mode,
+            version: availableVersion,
+            newId: freshRef.id,
+            detached: Boolean(target.detach),
+            baseStored: provenance.baseStored
+        });
+    } catch (error) {
+        console.error(error);
+        return res.status(500).json({
+            error: 'Update failed'
+        });
+    }
+};
+export default updateArtifactHandler;
+
+//# sourceMappingURL=update-artifact.js.map