mcp-scraper 0.44.4 → 0.46.0

package/dist/{server-W4JLSNKW.js → server-SMEHT3OU.js}

@@ -48,6 +48,10 @@ import {
 import {
   ApiErrorResponseSchema,
   ArtifactTemplateConfigSchema,
+  CommonsClaimPublicationInputSchema,
+  CommonsPreparePublicationInputSchema,
+  CommonsPublishEditorialInputSchema,
+  CommonsValidatePublicationInputSchema,
   CreateArtifactTemplateInputSchema,
   CreateEditorialReadingRoomInputSchema,
   CreateScheduledRunViewLinkInputSchema,
@@ -56,6 +60,7 @@ import {
   HttpMcpToolExecutor,
   InternalScheduledArtifactRenderRequestSchema,
   ListScheduledRunsQuerySchema,
+  LocalSourcebookSchemaTypeSchema,
   PublicScheduledRunTokenSchema,
   RenewEditorialReadingRoomDownloadInputSchema,
   SCHEDULED_ARTIFACT_TEMPLATE_PRESET,
@@ -72,11 +77,13 @@ import {
   configureReportSaving,
   createConnectedDataArtifact,
   createDirectoryCsvArtifact,
+  defaultLocalSourcebookSchemaType,
   exportFanout,
   handleMcpTasksHttpRequest,
   harvestTimeoutBudget,
   hashOwnerId,
   isLoopbackBaseUrl,
+  localSourcebookSchemaContract,
   outputBaseDir,
   registerBrowserAgentMcpTools,
   registerMemoryMcpTools,
@@ -85,8 +92,9 @@ import {
   renewConnectedDataArtifactDownload,
   renewDirectoryArtifactDownload,
   resolveDeploymentProfile,
+  resolveLocalSourcebookSchemaType,
   transcribeMediaUrl
-} from "./chunk-ZVOVPXDL.js";
+} from "./chunk-BP2IUIAH.js";
 import {
   auditImageUrls,
   auditImages,
@@ -142,7 +150,7 @@ import {
 } from "./chunk-3ZUBQQPQ.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-HFCIHZHA.js";
+} from "./chunk-TQKQK7OV.js";
 import {
   abandonExtractSettlement,
   countSuccessfulPages,
@@ -165,7 +173,7 @@ import {
   setExtractJobTotal,
   settleExtractJob,
   terminalExtractJobStatus
-} from "./chunk-WWIJ2NID.js";
+} from "./chunk-JFOT5JEL.js";
 import {
   BROWSER_OPEN_MIN_BALANCE_MC,
   CONCURRENCY_PRICE_ID,
@@ -178,6 +186,7 @@ import {
   CONNECTED_USAGE_RATE_POLICY,
   CONNECTED_USAGE_RATE_POLICY_VERSION,
   CREDIT_COST_CATALOG,
+  LISTING_WRITE_RATE_POLICY,
   LedgerOperation,
   MC_COSTS,
   MC_PER_CREDIT,
@@ -213,7 +222,7 @@ import {
   tierChangeLeavesPrivateOffer,
   tierCreditsPerInterval,
   vendorCostUsdToMc
-} from "./chunk-X5WDJ7D7.js";
+} from "./chunk-SOEYDWJU.js";
 import {
   CaptchaError,
   MapsSearchIncompletePageError,
@@ -3638,7 +3647,7 @@ async function generateOgImage(post) {
 
 // src/api/server.ts
 import { Resend as Resend3 } from "resend";
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 
 // src/api/kpo-extractor.ts
 import TurndownService from "turndown";
@@ -8667,7 +8676,7 @@ var siteExtractFn = inngest.createFunction(
       });
     }) : null;
     const finalized = await step.run("finalize", async () => {
-      const { assembleExtractArtifacts } = await import("./extract-bundle-U3MNYDKC.js");
+      const { assembleExtractArtifacts } = await import("./extract-bundle-DYMQRQWG.js");
       const current = await getExtractJob(jobId2);
       if (!current) throw new Error("extract job disappeared before finalization");
       const stored = await assembleExtractArtifacts(current, { branding, imageAudit });
@@ -12033,16 +12042,18 @@ async function createLocalSourcebookSubmission(input) {
     const existing = await db.execute({ sql: `SELECT * FROM local_sourcebook_submissions WHERE owner_user_id = ? AND idempotency_key = ? LIMIT 1`, args: [input.ownerUserId, input.idempotencyKey] });
     if (existing.rows[0]) {
       const submission = mapSubmission(existing.rows[0]);
-      if (submission.category !== input.category || submission.state !== input.state || submission.slug !== input.slug || submission.businessName !== input.businessName || submission.websiteUrl !== input.websiteUrl) throw new Error("Local Sourcebook idempotency key conflicts with a different listing identity.");
+      if (submission.category !== input.category || submission.state !== input.state || submission.slug !== input.slug || submission.businessName !== input.businessName || submission.websiteUrl !== input.websiteUrl || input.schemaOrgType != null && submission.coverage.schemaOrgType !== input.schemaOrgType) throw new Error("Local Sourcebook idempotency key conflicts with a different listing identity.");
       return submission;
     }
   }
   const id = `lsb_${randomUUID3().replace(/-/g, "")}`;
   const coverage = {
-    requested: ["website_crawl", "services_products", "service_areas", "genuine_images", "staff_team", "review_sources"],
+    requested: ["website_crawl", "structured_data", "services_products", "service_areas", "genuine_images", "staff_team", "review_sources"],
     crawl: { state: "queued", pagesDiscovered: 0, pagesCaptured: 0 },
     media: { state: "queued", genuineImagesCaptured: 0 },
-    reviews: { state: "queued", captured: 0, availableReported: null, stopReason: null }
+    reviews: { state: "queued", captured: 0, availableReported: null, stopReason: null },
+    ...input.schemaOrgType ? { schemaOrgType: input.schemaOrgType } : {},
+    ...input.billing ? { billing: { mode: "fixed_listing_write", ...input.billing } } : {}
   };
   await db.batch([
     { sql: `INSERT INTO local_sourcebook_submissions (id, owner_user_id, category, state, slug, business_name, website_url, coverage_json, idempotency_key) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, args: [id, input.ownerUserId, input.category, input.state, input.slug, input.businessName, input.websiteUrl, JSON.stringify(coverage), input.idempotencyKey ?? null] },
@@ -12062,13 +12073,17 @@ async function getLocalSourcebookDraft(id, ownerUserId) {
   const result = await getDb().execute({ sql: `SELECT payload_json FROM local_sourcebook_revisions WHERE submission_id = ? AND revision = ?`, args: [id, submission.draftRevision] });
   return result.rows[0] ? parseJson2(result.rows[0].payload_json) : null;
 }
-async function queueLocalSourcebookRefresh(id, ownerUserId) {
+async function queueLocalSourcebookRefresh(id, ownerUserId, billing) {
   const existing = await getLocalSourcebookSubmission(id, ownerUserId);
   if (!existing) return null;
   if (existing.status === "rejected" || existing.status === "unpublished") {
     throw new Error(`A ${existing.status} Local Sourcebook listing cannot be refreshed by its owner.`);
   }
-  const coverage = { ...existing.coverage, refreshRequestedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const coverage = {
+    ...existing.coverage,
+    refreshRequestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...billing ? { billing: { mode: "fixed_listing_write", ...billing } } : {}
+  };
   await getDb().execute({ sql: `UPDATE local_sourcebook_submissions SET status = 'queued', coverage_json = ?, acquisition_claimed_at = NULL, acquisition_error = NULL, updated_at = datetime('now') WHERE id = ? AND owner_user_id = ?`, args: [JSON.stringify(coverage), id, ownerUserId] });
   await event(id, "enrichment.queued", "owner", String(ownerUserId));
   return getLocalSourcebookSubmission(id, ownerUserId);
@@ -12774,6 +12789,80 @@ var MapsExtractor = class {
   }
 };
 
+// src/api/listing-write-billing.ts
+function operationFor(surface, kind) {
+  if (surface === "local_sourcebook") {
+    return kind === "create" ? LedgerOperation.LOCAL_SOURCEBOOK_CREATE : LedgerOperation.LOCAL_SOURCEBOOK_EDIT;
+  }
+  return kind === "create" ? LedgerOperation.COMMONS_CREATE : LedgerOperation.COMMONS_EDIT;
+}
+function refundOperationFor(surface, kind) {
+  if (surface === "local_sourcebook") {
+    return kind === "create" ? LedgerOperation.LOCAL_SOURCEBOOK_CREATE_REFUND : LedgerOperation.LOCAL_SOURCEBOOK_EDIT_REFUND;
+  }
+  return kind === "create" ? LedgerOperation.COMMONS_CREATE_REFUND : LedgerOperation.COMMONS_EDIT_REFUND;
+}
+function listingWritePrice(kind) {
+  return LISTING_WRITE_RATE_POLICY[kind];
+}
+function listingWriteDebitKey(surface, userId, idempotencyKey3) {
+  return `listing-write:${surface}:${userId}:${idempotencyKey3}`;
+}
+function publicListingWriteBilling(receipt) {
+  return {
+    surface: receipt.surface,
+    operation: receipt.kind,
+    credits: receipt.credits,
+    charged: !receipt.duplicate,
+    idempotentReplay: receipt.duplicate,
+    balanceCredits: receipt.balanceMc / MC_PER_CREDIT,
+    acquisitionIncluded: receipt.surface === "local_sourcebook"
+  };
+}
+async function chargeListingWrite(input) {
+  const price = listingWritePrice(input.kind);
+  const debitKey2 = listingWriteDebitKey(input.surface, input.userId, input.idempotencyKey);
+  const debit = await debitMcIdempotent(
+    input.userId,
+    price.mc,
+    operationFor(input.surface, input.kind),
+    `${input.surface}:${input.kind}`,
+    debitKey2
+  );
+  if (!debit.ok) return { insufficient: insufficientBalanceResponse(debit.balance_mc, price.mc) };
+  return {
+    surface: input.surface,
+    kind: input.kind,
+    userId: input.userId,
+    credits: price.credits,
+    amountMc: price.mc,
+    debitKey: debitKey2,
+    duplicate: debit.duplicate,
+    balanceMc: debit.balance_mc
+  };
+}
+async function refundListingWrite(receipt, reason) {
+  if (receipt.duplicate) return null;
+  return settleDebitMcIdempotent(
+    receipt.userId,
+    receipt.debitKey,
+    0,
+    refundOperationFor(receipt.surface, receipt.kind),
+    reason,
+    receipt.surface
+  );
+}
+async function refundPersistedListingWrite(input) {
+  return settleDebitMcIdempotent(
+    input.userId,
+    input.debitKey,
+    0,
+    refundOperationFor(input.surface, input.kind),
+    input.reason,
+    input.surface
+  );
+}
+
 // src/api/local-sourcebook-compiler.ts
 import { createHash as createHash3 } from "crypto";
 
@@ -13100,6 +13189,65 @@ function reviewStopReason(input, captured, exposed) {
   if (exposed && captured < exposed) return `Google Maps stopped exposing additional complete review cards after ${captured} of ${exposed} reported reviews.`;
   return `All ${captured} complete, unique review cards exposed during this acquisition were retained.`;
 }
+function buildLocalBusinessJsonLd(input) {
+  const businessId = `${input.profileUrl}#business`;
+  const business = {
+    "@type": input.schemaOrgType === "LocalBusiness" ? "LocalBusiness" : ["LocalBusiness", input.schemaOrgType],
+    "@id": businessId,
+    url: input.profileUrl,
+    name: input.name,
+    description: input.description,
+    ...input.phone ? { telephone: input.phone } : {},
+    ...input.address || input.locality || input.region || input.postalCode ? {
+      address: {
+        "@type": "PostalAddress",
+        ...input.address ? { streetAddress: input.address } : {},
+        ...input.locality ? { addressLocality: input.locality } : {},
+        ...input.region ? { addressRegion: input.region } : {},
+        ...input.postalCode ? { postalCode: input.postalCode } : {},
+        addressCountry: "US"
+      }
+    } : {},
+    ...Number.isFinite(input.latitude) && Number.isFinite(input.longitude) ? {
+      geo: { "@type": "GeoCoordinates", latitude: input.latitude, longitude: input.longitude }
+    } : {},
+    ...input.images.length ? { image: input.images } : {},
+    ...input.serviceAreas.length ? { areaServed: input.serviceAreas } : {},
+    ...input.services.length ? {
+      hasOfferCatalog: {
+        "@type": "OfferCatalog",
+        name: "Services",
+        itemListElement: input.services.map((name) => ({ "@type": "Offer", itemOffered: { "@type": "Service", name } }))
+      }
+    } : {},
+    ...Number.isFinite(input.rating) && Number.isFinite(input.ratingCount) && Number(input.ratingCount) > 0 ? {
+      aggregateRating: { "@type": "AggregateRating", ratingValue: input.rating, reviewCount: input.ratingCount, bestRating: 5, worstRating: 1 }
+    } : {},
+    sameAs: unique([input.website, input.mapsUrl], 10)
+  };
+  const graph = [business, {
+    "@type": "BreadcrumbList",
+    "@id": `${input.profileUrl}#breadcrumbs`,
+    itemListElement: [
+      { "@type": "ListItem", position: 1, name: "Local Sourcebook", item: "https://localsourcebook.com/" },
+      { "@type": "ListItem", position: 2, name: input.region || "State directory", item: input.stateUrl },
+      { "@type": "ListItem", position: 3, name: input.name, item: input.profileUrl }
+    ]
+  }];
+  if (input.faq.length) {
+    graph.push({
+      "@type": "FAQPage",
+      "@id": `${input.profileUrl}#faq`,
+      about: { "@id": businessId },
+      mainEntity: input.faq.map((item) => ({
+        "@type": "Question",
+        name: item.question,
+        acceptedAnswer: { "@type": "Answer", text: item.answer }
+      }))
+    });
+  }
+  return { "@context": "https://schema.org", "@graph": graph };
+}
 function compileLocalSourcebookListing(input) {
   const collectedAt = input.collectedAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const pages = successfulPages(input.site);
@@ -13169,6 +13317,33 @@ function compileLocalSourcebookListing(input) {
     }
   ];
   const publicUrls = localSourcebookPublicUrls(input.submission.category, input.submission.state, input.submission.slug);
+  const schemaOrgType = resolveLocalSourcebookSchemaType(input.submission.category, input.submission.coverage.schemaOrgType);
+  const listingName = maps?.name || input.submission.businessName;
+  const listingWebsite = maps?.website || input.submission.websiteUrl;
+  const listingMapsUrl = maps?.placeUrl || maps?.cidUrl || void 0;
+  const stateUrl = new URL(`/${input.submission.state.toLowerCase()}`, publicUrls.profileUrl).href;
+  const jsonLd = buildLocalBusinessJsonLd({
+    schemaOrgType,
+    profileUrl: publicUrls.profileUrl,
+    stateUrl,
+    name: listingName,
+    description: summary,
+    address: location2.address,
+    locality: location2.locality,
+    region: location2.region,
+    postalCode: location2.postalCode,
+    phone: maps?.phoneDisplay || maps?.phone || void 0,
+    website: listingWebsite,
+    mapsUrl: listingMapsUrl,
+    latitude: maps?.lat ?? void 0,
+    longitude: maps?.lng ?? void 0,
+    services,
+    serviceAreas,
+    images: media.map((item) => String(item.src)),
+    rating: Number.isFinite(rating) ? rating : void 0,
+    ratingCount: Number.isFinite(exposedCount) ? exposedCount : void 0,
+    faq
+  });
   const listing = {
     id: input.submission.id,
     publicationRevision: input.submission.draftRevision + 1,
@@ -13185,7 +13360,9 @@ function compileLocalSourcebookListing(input) {
       profile: publicUrls.profileUrl,
       reviews: publicUrls.reviewsUrl
     },
-    name: maps?.name || input.submission.businessName,
+    name: listingName,
+    schemaOrgType,
+    jsonLd,
     summary,
     description,
     address: location2.address,
@@ -13193,8 +13370,8 @@ function compileLocalSourcebookListing(input) {
     region: location2.region,
     postalCode: location2.postalCode,
     phone: maps?.phoneDisplay || maps?.phone || void 0,
-    website: maps?.website || input.submission.websiteUrl,
-    mapsUrl: maps?.placeUrl || maps?.cidUrl || void 0,
+    website: listingWebsite,
+    mapsUrl: listingMapsUrl,
     latitude: maps?.lat ?? void 0,
     longitude: maps?.lng ?? void 0,
     hours,
@@ -13234,11 +13411,12 @@ function compileLocalSourcebookListing(input) {
   return {
     listing,
     coverage: {
-      requested: ["website_crawl", "services_products", "service_areas", "genuine_images", "staff_team", "review_sources"],
+      requested: ["website_crawl", "structured_data", "services_products", "service_areas", "genuine_images", "staff_team", "review_sources"],
       crawl: { state: input.siteError ? "failed" : input.site?.truncated ? "partial" : "complete", pagesDiscovered: input.site?.spider.totalFound ?? 0, pagesCaptured: pages.length, requestedMaximum: input.requestedMaxPages, error: input.siteError ?? null },
       media: { state: input.siteError ? "failed" : "complete", genuineImagesCaptured: media.length, teamImagesCaptured: media.filter((item) => item.kind === "team").length },
       reviews: { state: input.mapsError || input.reviewBillingLimited ? "partial" : "complete", captured: reviews.length, availableReported: Number.isFinite(exposedCount) ? exposedCount : null, requestedMaximum: input.requestedMaxReviews, stopReason: reviewStopReason(input, reviews.length, Number.isFinite(exposedCount) ? exposedCount : void 0) },
       maps: { state: maps ? "complete" : "failed", exactPlaceUrl: maps?.placeUrl ?? null, cid: maps?.cidDecimal ?? maps?.cid ?? null, error: input.mapsError ?? null },
+      structuredData: { state: "complete", rootType: "LocalBusiness", schemaOrgType, graphNodes: jsonLd["@graph"].length },
       compiledAt: collectedAt
     }
   };
@@ -13323,110 +13501,83 @@ async function runLocalSourcebookAcquisition(submission, provider = createDefaul
   const user = await getUserById(submission.ownerUserId);
   if (!user) throw new Error("The submission owner is no longer active.");
   if (!user.subscription_tier) throw new Error("An active MCP Scraper subscription is required for acquisition.");
-  const billingCycle = `local-sourcebook:${submission.id}:revision:${submission.draftRevision}`;
-  const mapsDescription = `Local Sourcebook: ${submission.businessName}`;
-  const mapsHold = await debitMcIdempotent(
-    submission.ownerUserId,
-    MC_COSTS.maps_place,
-    LedgerOperation.MAPS_PLACE,
-    mapsDescription,
-    `${billingCycle}:maps-place`
-  );
-  if (!mapsHold.ok) throw new Error(`Insufficient credits: Local Sourcebook needs at least ${MC_COSTS.maps_place / 100} credits for exact-place acquisition before website pages and reviews.`);
-  const balanceAfterMapsHold = mapsHold.balance_mc;
-  const maxPages = Math.min(LOCAL_SOURCEBOOK_MAX_PAGES, Math.floor(balanceAfterMapsHold / MC_COSTS.page_scrape));
+  const storedBilling = submission.coverage.billing;
+  const inferredKind = submission.publishedRevision == null ? "create" : "edit";
+  const kind = storedBilling?.kind === "edit" ? "edit" : storedBilling?.kind === "create" ? "create" : inferredKind;
+  const price = listingWritePrice(kind);
+  let debitKey2 = typeof storedBilling?.debitKey === "string" ? storedBilling.debitKey : "";
+  if (!debitKey2) {
+    const fallback = await chargeListingWrite({
+      surface: "local_sourcebook",
+      kind,
+      userId: submission.ownerUserId,
+      idempotencyKey: `worker:${submission.id}:revision:${submission.draftRevision}`
+    });
+    if ("insufficient" in fallback) throw new Error(fallback.insufficient.message);
+    debitKey2 = fallback.debitKey;
+  }
+  const maxPages = LOCAL_SOURCEBOOK_MAX_PAGES;
   let site = null;
   let maps = null;
   let siteError = null;
   let mapsError = null;
-  let reviewBillingLimited = false;
-  let siteHoldMc = 0;
-  let siteActualMc = 0;
-  let mapsRefunded = false;
-  let reviewsBilledMc = 0;
-  if (maxPages < 1) {
-    siteError = "The subscriber balance covered exact-place acquisition but not a website page.";
-  } else {
-    siteHoldMc = maxPages * MC_COSTS.page_scrape;
-    const siteDescription = `Local Sourcebook: ${new URL(submission.websiteUrl).hostname}`;
-    const siteHold = await debitMcIdempotent(
-      submission.ownerUserId,
-      siteHoldMc,
-      LedgerOperation.EXTRACT_SITE_HOLD,
-      siteDescription,
-      `${billingCycle}:website-hold`
-    );
-    if (!siteHold.ok) {
-      siteError = "The subscriber balance changed before the website acquisition hold could be placed.";
-      siteHoldMc = 0;
-    } else {
-      try {
-        site = await provider.extractWebsite(submission, maxPages);
-        const successfulPages2 = site.pages.filter(isPageExtractionSuccessful).length;
-        siteActualMc = successfulPages2 * MC_COSTS.page_scrape;
-        const refund = siteHoldMc - siteActualMc;
-        if (refund > 0) await creditMcIdempotent(submission.ownerUserId, refund, LedgerOperation.EXTRACT_SITE_REFUND, `Local Sourcebook unused website-page hold: ${submission.id}`, `${billingCycle}:website-unused-refund`);
-        await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_website", status: "done", query: submission.websiteUrl, resultCount: successfulPages2, result: { submissionId: submission.id, discovered: site.spider.totalFound, captured: successfulPages2, truncated: site.truncated } });
-      } catch (error) {
-        siteError = errorMessage2(error);
-        await creditMcIdempotent(submission.ownerUserId, siteHoldMc, LedgerOperation.EXTRACT_SITE_REFUND, `Local Sourcebook failed website acquisition: ${submission.id}`, `${billingCycle}:website-failure-refund`);
-        siteHoldMc = 0;
-        await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_website", status: "failed", query: submission.websiteUrl, error: siteError });
-      }
-    }
-  }
   try {
-    maps = await provider.extractMaps(submission, LOCAL_SOURCEBOOK_MAX_REVIEWS);
-    validateLocalSourcebookMapsIdentity(submission, maps);
-    const completeReviewCount = maps.reviews.filter((review) => Boolean(review.text?.trim())).length;
-    if (completeReviewCount > 0) {
-      const reviewCost = completeReviewCount * MC_COSTS.maps_review;
-      const debit = await debitMcIdempotent(
-        submission.ownerUserId,
-        reviewCost,
-        LedgerOperation.MAPS_REVIEW,
-        `Local Sourcebook reviews: ${submission.businessName}`,
-        `${billingCycle}:maps-reviews`
-      );
-      if (debit.ok) {
-        reviewsBilledMc = reviewCost;
-      } else {
-        reviewBillingLimited = true;
-        maps.reviews = [];
-      }
+    try {
+      site = await provider.extractWebsite(submission, maxPages);
+      const successfulPages2 = site.pages.filter(isPageExtractionSuccessful).length;
+      await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_website", status: "done", query: submission.websiteUrl, resultCount: successfulPages2, result: { submissionId: submission.id, discovered: site.spider.totalFound, captured: successfulPages2, truncated: site.truncated } });
+    } catch (error) {
+      siteError = errorMessage2(error);
+      await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_website", status: "failed", query: submission.websiteUrl, error: siteError });
     }
-    await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_maps", status: "done", query: submission.businessName, location: submission.state.toUpperCase(), resultCount: maps.reviews.length, result: { submissionId: submission.id, placeUrl: maps.placeUrl, cid: maps.cidDecimal ?? maps.cid, reviewsStatus: maps.reviewsStatus, reviewsRetained: maps.reviews.length, services: maps.services.length, areasServed: maps.areasServed.length } });
+    try {
+      maps = await provider.extractMaps(submission, LOCAL_SOURCEBOOK_MAX_REVIEWS);
+      validateLocalSourcebookMapsIdentity(submission, maps);
+      await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_maps", status: "done", query: submission.businessName, location: submission.state.toUpperCase(), resultCount: maps.reviews.length, result: { submissionId: submission.id, placeUrl: maps.placeUrl, cid: maps.cidDecimal ?? maps.cid, reviewsStatus: maps.reviewsStatus, reviewsRetained: maps.reviews.length, services: maps.services.length, areasServed: maps.areasServed.length } });
+    } catch (error) {
+      mapsError = errorMessage2(error);
+      maps = null;
+      await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_maps", status: "failed", query: submission.businessName, location: submission.state.toUpperCase(), error: mapsError });
+    }
+    if (!maps) throw new Error(`Exact-place acquisition is required before publication. Maps: ${mapsError || "not available"}. Website: ${siteError || (site ? "captured" : "not available")}.`);
+    const compiled = compileLocalSourcebookListing({
+      submission,
+      site,
+      maps,
+      requestedMaxPages: maxPages,
+      requestedMaxReviews: LOCAL_SOURCEBOOK_MAX_REVIEWS,
+      siteError,
+      mapsError,
+      reviewBillingLimited: false
+    });
+    const coverage = {
+      ...compiled.coverage,
+      billing: {
+        mode: "fixed_listing_write",
+        kind,
+        credits: price.credits,
+        amountMc: price.mc,
+        debitKey: debitKey2,
+        acquisitionIncluded: true
+      }
+    };
+    const completed = await completeLocalSourcebookAcquisition(submission.id, compiled.listing, coverage, submission.draftRevision);
+    if (!completed) throw new Error("The Local Sourcebook draft could not be saved after acquisition.");
+    return completed;
   } catch (error) {
-    mapsError = errorMessage2(error);
-    maps = null;
-    await creditMcIdempotent(submission.ownerUserId, MC_COSTS.maps_place, LedgerOperation.REFUND, `Local Sourcebook failed exact-place acquisition: ${submission.id}`, `${billingCycle}:maps-failure-refund`);
-    mapsRefunded = true;
-    await logRequestEvent({ userId: submission.ownerUserId, source: "local_sourcebook_maps", status: "failed", query: submission.businessName, location: submission.state.toUpperCase(), error: mapsError });
-  }
-  if (!maps) throw new Error(`Exact-place acquisition is required before publication. Maps: ${mapsError || "not available"}. Website: ${siteError || (site ? "captured" : "not available")}.`);
-  const compiled = compileLocalSourcebookListing({
-    submission,
-    site,
-    maps,
-    requestedMaxPages: maxPages,
-    requestedMaxReviews: LOCAL_SOURCEBOOK_MAX_REVIEWS,
-    siteError,
-    mapsError,
-    reviewBillingLimited
-  });
-  const coverage = {
-    ...compiled.coverage,
-    billing: {
-      websiteHeldMc: siteHoldMc,
-      websiteUsedMc: siteActualMc,
-      mapsUsedMc: mapsRefunded ? 0 : MC_COSTS.maps_place,
-      reviewsUsedMc: reviewsBilledMc,
-      reviewBillingLimited
+    const current = await getLocalSourcebookSubmission(submission.id).catch(() => null);
+    const revisionAlreadyPublished = current?.status === "published" && current.publishedRevision != null && current.draftRevision > submission.draftRevision;
+    if (!revisionAlreadyPublished) {
+      await refundPersistedListingWrite({
+        surface: "local_sourcebook",
+        kind,
+        userId: submission.ownerUserId,
+        debitKey: debitKey2,
+        reason: `Local Sourcebook acquisition failed: ${errorMessage2(error)}`
+      }).catch(() => null);
     }
-  };
-  const completed = await completeLocalSourcebookAcquisition(submission.id, compiled.listing, coverage, submission.draftRevision);
-  if (!completed) throw new Error("The Local Sourcebook draft could not be saved after acquisition.");
-  return completed;
+    throw error;
+  }
 }
 async function processLocalSourcebookSubmission(submissionId) {
   const submission = await claimLocalSourcebookAcquisition(submissionId);
@@ -21322,6 +21473,7 @@ var DirectoryIdentitySchema = z25.object({
   state: z25.string().trim().length(2).transform((value) => value.toLowerCase()),
   businessName: z25.string().trim().min(2).max(160),
   websiteUrl: z25.url().refine((value) => /^https?:\/\//.test(value), "websiteUrl must use http or https"),
+  schemaOrgType: LocalSourcebookSchemaTypeSchema.optional(),
   slug: z25.string().trim().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100).optional(),
   tags: z25.array(z25.string().trim().min(1).max(60)).max(20).default([]),
   idempotencyKey: z25.string().trim().min(8).max(200)
@@ -21406,7 +21558,7 @@ async function resolveLocalSourcebookTags(candidates) {
 function getLocalSourcebookContract(category) {
   return {
     name: "Local Sourcebook listing",
-    version: "local_sourcebook_listing_v2",
+    version: "local_sourcebook_listing_v3",
     purpose: "An owner-scoped, evidence-backed local business record with a separate public profile and complete captured-review archive.",
     categories: LOCAL_SOURCEBOOK_CATEGORIES,
     selectedCategory: category ?? null,
@@ -21417,11 +21569,14 @@ function getLocalSourcebookContract(category) {
       reviews: "https://{category}.localsourcebook.com/{state}/{business-slug}/reviews"
     },
     requiredCreateFields: ["category", "state", "businessName", "websiteUrl", "tags", "idempotencyKey"],
-    systemCompiledSections: ["identity", "services/products", "service areas/locations", "genuine media", "reviews and theme counts", "evidence", "answered FAQ", "collection receipts"],
+    optionalCreateFields: ["schemaOrgType"],
+    systemCompiledSections: ["identity", "LocalBusiness JSON-LD", "services/products", "service areas/locations", "genuine media", "reviews and theme counts", "evidence", "answered FAQ", "collection receipts"],
     workflow: ["list-local-sourcebook-tags", "get-local-sourcebook-contract", "prepare-local-sourcebook-write", "validate-local-sourcebook-write", "local-sourcebook-capture", "local_sourcebook_submission_status"],
     ownership: "Only the MCP Scraper account that captures a listing can read it or request a paid evidence refresh.",
+    billing: { validationCredits: 0, createCredits: 10, editCredits: 2, acquisitionIncluded: true, chargeEvent: "accepted_write" },
     acquisition: { websitePagesMaximum: 100, reviewsMaximum: 500, exactMapsIdentityRequired: true, partialResultsRequireStoppingReasons: true },
     publication: { automatic: true, evidenceCompiledOnly: true, ownerAuthoredClaimsAccepted: false, adminReviewRequired: false, lastPublishedRevisionRemainsPublicDuringRefresh: true },
+    structuredData: localSourcebookSchemaContract(category),
     tagPolicy: { inspectVocabularyFirst: true, minimum: 1, maximum: 20, newTagsRequire: ["central=true", "reusable=true", "description"], newTagsStartAs: "pending" }
   };
 }
@@ -21436,17 +21591,20 @@ async function prepareLocalSourcebookWrite(input) {
   ];
   const tagResolutions = await resolveLocalSourcebookTags(candidates);
   const publicUrls = localSourcebookPublicUrls(parsed.category, parsed.state, slug2);
+  const schemaOrgType = parsed.schemaOrgType ?? defaultLocalSourcebookSchemaType(parsed.category);
   return {
     ok: true,
     route: { category: parsed.category, state: parsed.state, slug: slug2, ...publicUrls },
-    proposedWrite: { ...parsed, slug: slug2, tags: tagResolutions.filter((item) => item.action === "reuse").map((item) => item.tag) },
+    proposedWrite: { ...parsed, schemaOrgType, slug: slug2, tags: tagResolutions.filter((item) => item.action === "reuse").map((item) => item.tag) },
     contract: getLocalSourcebookContract(parsed.category),
     tagResolutions,
     instructions: [
       "Resolve every review candidate before capture; do not silently create a near-duplicate tag.",
       "Call validate-local-sourcebook-write with the proposed identity, resolved tags, and any required tag decisions.",
+      "Keep the proposed schemaOrgType or choose a more specific accepted LocalBusiness subtype from the contract. Arbitrary JSON-LD is not accepted.",
       "Call local-sourcebook-capture only after validation returns valid=true. Capture queues paid acquisition and automatically publishes the resulting system-compiled evidence revision.",
-      "Owners cannot supply public listing claims directly. Request local_sourcebook_refresh when source-backed public facts need to be reacquired."
+      "Creating the listing costs 10 Credits total, including acquisition. Validation is free.",
+      "Owners cannot supply public listing claims directly. A source-backed local_sourcebook_refresh costs 2 Credits."
     ]
   };
 }
@@ -21456,7 +21614,10 @@ async function validateLocalSourcebookWrite(input) {
   let normalizedIdentity2;
   const parsedIdentity = DirectoryIdentitySchema.safeParse(input.identity);
   if (!parsedIdentity.success) errors.push(...parsedIdentity.error.issues.map((issue) => `identity.${issue.path.join(".")}: ${issue.message}`));
-  else normalizedIdentity2 = parsedIdentity.data;
+  else normalizedIdentity2 = {
+    ...parsedIdentity.data,
+    schemaOrgType: parsedIdentity.data.schemaOrgType ?? defaultLocalSourcebookSchemaType(parsedIdentity.data.category)
+  };
   const candidates = input.tagCandidates ?? (normalizedIdentity2?.tags.map((tag) => ({ tag })) ?? []);
   const resolutions = await resolveLocalSourcebookTags(candidates);
   const decisions = new Map((input.tagDecisions ?? []).map((decision) => [normalizeTag(decision.tag), decision]));
@@ -21505,6 +21666,7 @@ var SubmitSchema = z26.object({
   state: z26.string().trim().length(2).transform((value) => value.toLowerCase()),
   businessName: z26.string().trim().min(2).max(160),
   websiteUrl: z26.url().refine((value) => /^https?:\/\//.test(value), "websiteUrl must use http or https"),
+  schemaOrgType: LocalSourcebookSchemaTypeSchema.optional(),
   slug: z26.string().trim().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100).optional(),
   idempotencyKey: z26.string().trim().min(8).max(200).optional()
 }).strict();
@@ -21561,13 +21723,19 @@ localSourcebookApp.post("/capture", createApiKeyAuth(), async (c) => {
   if (!parsed.success) return c.json({ error: "invalid_capture_request", issues: parsed.error.issues }, 400);
   const validation = await validateLocalSourcebookWrite(parsed.data);
   if (!validation.valid) return c.json({ error: "invalid_directory_write", ...validation }, 400);
+  let billing = null;
+  let persisted = false;
   try {
     const identity = validation.normalizedIdentity;
-    if (!parsed.data.idempotencyKey && !identity.idempotencyKey) {
+    const idempotencyKey3 = parsed.data.idempotencyKey ?? identity.idempotencyKey;
+    if (!idempotencyKey3) {
       return c.json({ error: "idempotency_key_required", message: "A stable idempotencyKey is required for a new Local Sourcebook capture." }, 400);
     }
     const listingSlug = identity.slug ?? slug(identity.businessName);
     const publicUrls = localSourcebookPublicUrls(identity.category, identity.state, listingSlug);
+    const charged = await chargeListingWrite({ surface: "local_sourcebook", kind: "create", userId: Number(user.id), idempotencyKey: idempotencyKey3 });
+    if ("insufficient" in charged) return c.json(charged.insufficient, 402);
+    billing = charged;
     const submission = await createLocalSourcebookSubmission({
       ownerUserId: Number(user.id),
       category: identity.category,
@@ -21575,7 +21743,9 @@ localSourcebookApp.post("/capture", createApiKeyAuth(), async (c) => {
       slug: listingSlug,
       businessName: identity.businessName,
       websiteUrl: identity.websiteUrl,
-      idempotencyKey: parsed.data.idempotencyKey ?? identity.idempotencyKey,
+      schemaOrgType: identity.schemaOrgType,
+      idempotencyKey: idempotencyKey3,
+      billing: { kind: billing.kind, credits: billing.credits, amountMc: billing.amountMc, debitKey: billing.debitKey },
       payload: {
         id: "",
         category: identity.category,
@@ -21583,6 +21753,7 @@ localSourcebookApp.post("/capture", createApiKeyAuth(), async (c) => {
         slug: listingSlug,
         name: identity.businessName,
         websiteUrl: identity.websiteUrl,
+        schemaOrgType: identity.schemaOrgType,
         tags: validation.normalizedTags,
         canonicalPaths: { profile: publicUrls.profilePath, reviews: publicUrls.reviewsPath },
         canonicalUrls: { profile: publicUrls.profileUrl, reviews: publicUrls.reviewsUrl },
@@ -21593,10 +21764,12 @@ localSourcebookApp.post("/capture", createApiKeyAuth(), async (c) => {
         reviews: []
       }
     });
+    persisted = true;
     await persistLocalSourcebookTags(submission.id, Number(user.id), validation.normalizedTags, parsed.data.tagDecisions);
     const dispatched = await dispatchLocalSourcebookAcquisition(submission.id).catch(() => false);
-    return c.json({ ok: true, valid: true, submission, publicUrls: localSourcebookPublicationLinks(submission), normalizedTags: validation.normalizedTags, acquisition: { queued: true, dispatched }, acquisitionPlan: acquisitionPlan(identity.websiteUrl) }, 202);
+    return c.json({ ok: true, valid: true, submission, publicUrls: localSourcebookPublicationLinks(submission), normalizedTags: validation.normalizedTags, acquisition: { queued: true, dispatched }, acquisitionPlan: acquisitionPlan(identity.websiteUrl), billing: publicListingWriteBilling(billing) }, 202);
   } catch (error) {
+    if (billing && !persisted) await refundListingWrite(billing, "Local Sourcebook creation failed before persistence.").catch(() => null);
     const message = error instanceof Error ? error.message : String(error);
     const conflict = message.includes("revision conflict") ? "revision_conflict" : message.includes("idempotency key conflicts") ? "idempotency_conflict" : null;
     return c.json({ error: conflict ?? "capture_failed", message }, conflict ? 409 : 400);
@@ -21608,13 +21781,22 @@ localSourcebookApp.post("/submissions", createApiKeyAuth(), async (c) => {
   const parsed = SubmitSchema.safeParse(await c.req.json().catch(() => null));
   if (!parsed.success) return c.json({ error: "invalid_submission", issues: parsed.error.issues }, 400);
   const input = parsed.data;
+  if (!input.idempotencyKey) return c.json({ error: "idempotency_key_required", message: "A stable idempotencyKey is required for a new Local Sourcebook listing." }, 400);
   const listingSlug = input.slug ?? slug(input.businessName);
+  const schemaOrgType = input.schemaOrgType ?? defaultLocalSourcebookSchemaType(input.category);
   const publicUrls = localSourcebookPublicUrls(input.category, input.state, listingSlug);
+  let billing = null;
+  let persisted = false;
   try {
+    const charged = await chargeListingWrite({ surface: "local_sourcebook", kind: "create", userId: Number(user.id), idempotencyKey: input.idempotencyKey });
+    if ("insufficient" in charged) return c.json(charged.insufficient, 402);
+    billing = charged;
     const submission = await createLocalSourcebookSubmission({
       ownerUserId: Number(user.id),
       ...input,
+      schemaOrgType,
       slug: listingSlug,
+      billing: { kind: billing.kind, credits: billing.credits, amountMc: billing.amountMc, debitKey: billing.debitKey },
       payload: {
         id: "",
         category: input.category,
@@ -21622,6 +21804,7 @@ localSourcebookApp.post("/submissions", createApiKeyAuth(), async (c) => {
         slug: listingSlug,
         name: input.businessName,
         websiteUrl: input.websiteUrl,
+        schemaOrgType,
         canonicalPaths: { profile: publicUrls.profilePath, reviews: publicUrls.reviewsPath },
         canonicalUrls: { profile: publicUrls.profileUrl, reviews: publicUrls.reviewsUrl },
         verificationState: "submitted",
@@ -21631,9 +21814,11 @@ localSourcebookApp.post("/submissions", createApiKeyAuth(), async (c) => {
         reviews: []
       }
     });
+    persisted = true;
     const dispatched = await dispatchLocalSourcebookAcquisition(submission.id).catch(() => false);
-    return c.json({ ok: true, submission, publicUrls: localSourcebookPublicationLinks(submission), acquisition: { queued: true, dispatched }, acquisitionPlan: acquisitionPlan(input.websiteUrl) }, 202);
+    return c.json({ ok: true, submission, publicUrls: localSourcebookPublicationLinks(submission), acquisition: { queued: true, dispatched }, acquisitionPlan: acquisitionPlan(input.websiteUrl), billing: publicListingWriteBilling(billing) }, 202);
   } catch (error) {
+    if (billing && !persisted) await refundListingWrite(billing, "Local Sourcebook creation failed before persistence.").catch(() => null);
     return c.json({ error: "submission_conflict", message: error instanceof Error ? error.message : String(error) }, 409);
   }
 });
@@ -21650,12 +21835,35 @@ localSourcebookApp.on(["PATCH", "POST"], "/submissions/:id/draft", createApiKeyA
 localSourcebookApp.post("/submissions/:id/refresh", createApiKeyAuth(), async (c) => {
   const user = c.get("user");
   if (!user.subscription_tier) return c.json({ error: "subscription_required" }, 402);
+  const userId = Number(user.id);
+  const existing = await getLocalSourcebookSubmission(c.req.param("id"), userId);
+  if (!existing) return c.json({ error: "not_found" }, 404);
+  if (existing.status === "rejected" || existing.status === "unpublished") {
+    return c.json({ error: "moderated_listing", message: `A ${existing.status} Local Sourcebook listing cannot be refreshed by its owner.` }, 409);
+  }
+  if (existing.status === "queued" || existing.status === "enriching") {
+    return c.json({ error: "acquisition_in_progress", message: "This listing already has an acquisition in progress." }, 409);
+  }
+  const idempotencyKey3 = `refresh:${existing.id}:revision:${existing.draftRevision}`;
+  let billing = null;
   try {
-    const submission = await queueLocalSourcebookRefresh(c.req.param("id"), Number(user.id));
-    if (!submission) return c.json({ error: "not_found" }, 404);
+    const charged = await chargeListingWrite({ surface: "local_sourcebook", kind: "edit", userId, idempotencyKey: idempotencyKey3 });
+    if ("insufficient" in charged) return c.json(charged.insufficient, 402);
+    billing = charged;
+    const submission = await queueLocalSourcebookRefresh(c.req.param("id"), userId, {
+      kind: billing.kind,
+      credits: billing.credits,
+      amountMc: billing.amountMc,
+      debitKey: billing.debitKey
+    });
+    if (!submission) {
+      await refundListingWrite(billing, "Local Sourcebook listing was not found before refresh persistence.").catch(() => null);
+      return c.json({ error: "not_found" }, 404);
+    }
     const dispatched = await dispatchLocalSourcebookAcquisition(submission.id).catch(() => false);
-    return c.json({ ok: true, submission, publicUrls: localSourcebookPublicationLinks(submission), acquisition: { queued: true, dispatched }, acquisitionPlan: acquisitionPlan(submission.websiteUrl) }, 202);
+    return c.json({ ok: true, submission, publicUrls: localSourcebookPublicationLinks(submission), acquisition: { queued: true, dispatched }, acquisitionPlan: acquisitionPlan(submission.websiteUrl), billing: publicListingWriteBilling(billing) }, 202);
   } catch (error) {
+    if (billing) await refundListingWrite(billing, "Local Sourcebook refresh failed before persistence.").catch(() => null);
     return c.json({ error: "moderated_listing", message: error instanceof Error ? error.message : String(error) }, 409);
   }
 });
@@ -30641,7 +30849,7 @@ import { z as z32 } from "zod";
 
 // src/api/commons-repository.ts
 import { createHash as createHash12, randomUUID as randomUUID15 } from "crypto";
-var COMMONS_SCHEMA_VERSION = "2026-08-04.2";
+var COMMONS_SCHEMA_VERSION = "2026-08-04.3";
 var DEFAULT_COMMONS_BASE_URL = "https://transparent-commons.cc";
 var DEFAULT_ENTITY_TYPE = "PublicArticle";
 var COMMONS_ENTITY_PROFILES = {
@@ -30923,6 +31131,54 @@ async function ensureCommonsSchema() {
     },
     { sql: `CREATE INDEX IF NOT EXISTS commons_index_documents_status_updated ON commons_index_documents(embedding_status, updated_at DESC)`, args: [] },
     { sql: `CREATE INDEX IF NOT EXISTS commons_index_documents_entity_type ON commons_index_documents(entity_id, document_type)`, args: [] },
+    {
+      sql: `
+        CREATE TABLE IF NOT EXISTS commons_publications (
+          id TEXT PRIMARY KEY,
+          owner_user_id INTEGER NOT NULL REFERENCES users(id),
+          subdomain TEXT NOT NULL UNIQUE,
+          title TEXT NOT NULL,
+          description TEXT NOT NULL DEFAULT '',
+          claim_idempotency_key TEXT NOT NULL,
+          latest_edition_id TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          UNIQUE(owner_user_id),
+          UNIQUE(owner_user_id, claim_idempotency_key)
+        )
+      `,
+      args: []
+    },
+    { sql: `CREATE INDEX IF NOT EXISTS commons_publications_updated ON commons_publications(updated_at DESC)`, args: [] },
+    {
+      sql: `
+        CREATE TABLE IF NOT EXISTS commons_publication_editions (
+          id TEXT PRIMARY KEY,
+          publication_id TEXT NOT NULL REFERENCES commons_publications(id),
+          owner_user_id INTEGER NOT NULL REFERENCES users(id),
+          edition_slug TEXT NOT NULL,
+          revision INTEGER NOT NULL,
+          title TEXT NOT NULL,
+          site_json TEXT NOT NULL,
+          deck TEXT NOT NULL,
+          articles_json TEXT NOT NULL,
+          html TEXT NOT NULL,
+          filename TEXT NOT NULL,
+          sha256 TEXT NOT NULL,
+          article_count INTEGER NOT NULL,
+          word_count INTEGER NOT NULL,
+          bytes INTEGER NOT NULL,
+          warnings_json TEXT NOT NULL DEFAULT '[]',
+          idempotency_key TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          published_at TEXT NOT NULL,
+          UNIQUE(publication_id, edition_slug, revision),
+          UNIQUE(owner_user_id, idempotency_key)
+        )
+      `,
+      args: []
+    },
+    { sql: `CREATE INDEX IF NOT EXISTS commons_publication_editions_publication_published ON commons_publication_editions(publication_id, published_at DESC)`, args: [] },
     {
       sql: "INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)",
       args: [COMMONS_SCHEMA_VERSION]
@@ -31027,6 +31283,12 @@ async function prepareCommonsEntity(input, user) {
       writePath: "commons_prepare_entity -> commons_validate_entity -> commons_submit_entity"
     },
     contract,
+    billing: {
+      validationCredits: LISTING_WRITE_RATE_POLICY.validationCredits,
+      createCredits: LISTING_WRITE_RATE_POLICY.create.credits,
+      editCredits: LISTING_WRITE_RATE_POLICY.edit.credits,
+      chargeEvent: LISTING_WRITE_RATE_POLICY.chargeEvent
+    },
     duplicateCandidates,
     tagResolutions,
     headingPlan: {
@@ -31041,7 +31303,8 @@ async function prepareCommonsEntity(input, user) {
       "Use the returned profile as a contract, not a rigid empty template: do not include History, Reception, Pricing, Timeline, or similar sections unless source evidence supports them.",
       "Write neutral encyclopedia prose. Do not paste raw scrape Markdown, marketing layout fragments, or empty/filler headings.",
       "Attach a featured image for auto-publish eligibility, preserve original URL/source byline/relCanonical when republishing, and put media assets in the media array.",
-      "Call commons_validate_entity with the composed payload before commons_submit_entity."
+      "Call commons_validate_entity with the composed payload before commons_submit_entity.",
+      "Validation is free. Submitting a new entity costs 10 Credits; submitting an edit to an existing entity costs 2 Credits."
     ]
   };
 }
@@ -31130,6 +31393,14 @@ async function getCommonsEntity(idOrSlug) {
   });
   return result.rows[0] ? rowToEntity(result.rows[0]) : null;
 }
+async function classifyCommonsWrite(input, user) {
+  await ensureCommonsSchema();
+  const normalized = normalizeSubmitInput(input);
+  const existingProposal = await findProposalByIdempotency(user.id, normalized.idempotencyKey);
+  if (existingProposal) return existingProposal.proposalType === "edit_entity" ? "edit" : "create";
+  const existing = await findEntityBySlugOrIdAnyStatus(normalized.slug, normalized.entityId);
+  return existing ? "edit" : "create";
+}
 async function submitCommonsEntity(input, user) {
   await ensureCommonsSchema();
   const normalized = normalizeSubmitInput(input);
@@ -31394,7 +31665,8 @@ function commonsDatabaseReport() {
       normalWorkflow: ["commons_prepare_entity", "commons_validate_entity", "commons_submit_entity"],
       writesCreate: ["commons_proposals", "commons_ledger", "commons_entities when accepted"],
       safeAutoPublish: "New non-conflicting entities with title, description, featured image, and body/source evidence.",
-      conflictBehavior: "Existing entity edits require baseRevision. Otherwise the proposal is pending_review."
+      conflictBehavior: "Existing entity edits require baseRevision. Otherwise the proposal is pending_review.",
+      billing: { validationCredits: 0, createCredits: LISTING_WRITE_RATE_POLICY.create.credits, editCredits: LISTING_WRITE_RATE_POLICY.edit.credits }
     },
     searchCorpus: ["title", "disambiguationName", "description", "tags", "keywords", "relatedEntities", "bodyMarkdown", "sections", "media", "source metadata", "jsonLd"],
     indexing: commonsIndexingPolicy(),
@@ -32484,6 +32756,392 @@ var CommonsRepositoryError = class extends Error {
   httpStatus;
 };
 
+// src/api/commons-publication-repository.ts
+import { createHash as createHash13, randomUUID as randomUUID16 } from "crypto";
+var PUBLICATION_ROOT_DOMAIN = process.env.COMMONS_PUBLICATION_ROOT_DOMAIN || "transparent-commons.cc";
+var RESERVED_SUBDOMAINS = /* @__PURE__ */ new Set([
+  "admin",
+  "api",
+  "app",
+  "assets",
+  "auth",
+  "blog",
+  "cdn",
+  "docs",
+  "help",
+  "login",
+  "mail",
+  "mcp",
+  "signup",
+  "sitemap",
+  "static",
+  "support",
+  "transparent-commons",
+  "transparentcommons",
+  "www",
+  "wiki"
+]);
+var CommonsPublicationError = class extends Error {
+  constructor(code, message, httpStatus = 400) {
+    super(message);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.name = "CommonsPublicationError";
+  }
+  code;
+  httpStatus;
+};
+async function prepareCommonsPublication(input, user) {
+  await ensureCommonsSchema();
+  const subdomain = normalizePublicationSubdomain(input.requestedSubdomain);
+  const [owned, claimed] = await Promise.all([
+    getCommonsPublicationForOwner(Number(user.id)),
+    getCommonsPublicationBySubdomain(subdomain)
+  ]);
+  const availability = claimed ? claimed.ownerUserId === Number(user.id) ? "owned_by_caller" : "unavailable" : "available";
+  return {
+    requestedSubdomain: input.requestedSubdomain,
+    normalizedSubdomain: subdomain,
+    availability,
+    requestedPublicUrl: publicationPublicUrl(subdomain),
+    currentPublication: owned,
+    contract: {
+      ownership: "One publication per authenticated MCP Scraper account.",
+      permanence: "Claimed names are stable and globally unique.",
+      renderer: "Published editions use the MCP Scraper editorial reading-room renderer.",
+      revisionRule: "Editing an existing edition requires its current baseRevision.",
+      publicRoutes: ["/", "/archive", "/editions/{editionSlug}"],
+      workflow: [
+        "commons_prepare_publication",
+        "commons_validate_publication",
+        "commons_claim_publication",
+        "commons_publish_editorial"
+      ]
+    },
+    proposed: {
+      title: cleanText(input.title, 140) || publicationTitleFromSubdomain(subdomain),
+      description: cleanText(input.description, 500)
+    }
+  };
+}
+async function validateCommonsPublication(input, user) {
+  await ensureCommonsSchema();
+  const errors = [];
+  const warnings = [];
+  let subdomain = "";
+  try {
+    subdomain = normalizePublicationSubdomain(input.requestedSubdomain || input.publicationSubdomain || "");
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  const publication = subdomain ? await getCommonsPublicationBySubdomain(subdomain) : null;
+  if (input.operation === "claim") {
+    const owned = await getCommonsPublicationForOwner(Number(user.id));
+    if (publication && publication.ownerUserId !== Number(user.id)) errors.push("That publication name is already claimed by another account.");
+    if (owned && owned.subdomain !== subdomain) errors.push(`This account already owns ${owned.publicUrl}.`);
+    if (!cleanText(input.title, 140)) warnings.push("No display title was supplied; the publication name will be title-cased.");
+  } else {
+    if (!publication) errors.push("Claim this publication name before publishing an edition.");
+    else if (publication.ownerUserId !== Number(user.id)) errors.push("Only the account that claimed this publication can publish to it.");
+    if (!input.edition) errors.push("A complete editorial reading-room edition is required for publish validation.");
+    if (input.edition) {
+      try {
+        renderEditorialReadingRoom(input.edition);
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+      const slug2 = normalizeEditionSlug(input.editionSlug || input.edition.site.slug);
+      const latest = publication ? await getLatestEdition(publication.id, slug2) : null;
+      if (latest && input.baseRevision === void 0) errors.push(`Edition ${slug2} already exists at revision ${latest.revision}; supply baseRevision to edit it.`);
+      if (latest && input.baseRevision !== void 0 && latest.revision !== input.baseRevision) {
+        errors.push(`Edition ${slug2} is revision ${latest.revision}; the proposed edit targeted ${input.baseRevision}.`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    operation: input.operation,
+    normalizedSubdomain: subdomain || null,
+    publicUrl: subdomain ? publicationPublicUrl(subdomain) : null,
+    errors,
+    warnings,
+    publication
+  };
+}
+async function claimCommonsPublication(input, user) {
+  await ensureCommonsSchema();
+  const subdomain = normalizePublicationSubdomain(input.requestedSubdomain);
+  const userId = Number(user.id);
+  const existingOwned = await getCommonsPublicationForOwner(userId);
+  if (existingOwned) {
+    if (existingOwned.subdomain === subdomain) return { publication: existingOwned, idempotentReplay: true };
+    throw new CommonsPublicationError("publication_already_claimed", `This account already owns ${existingOwned.publicUrl}.`, 409);
+  }
+  const existingName = await getCommonsPublicationBySubdomain(subdomain);
+  if (existingName) throw new CommonsPublicationError("publication_name_unavailable", "That publication name is already claimed.", 409);
+  const id = `tcpub_${randomUUID16()}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    await getDb().execute({
+      sql: `
+        INSERT INTO commons_publications (
+          id, owner_user_id, subdomain, title, description, claim_idempotency_key, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args: [
+        id,
+        userId,
+        subdomain,
+        cleanText(input.title, 140) || publicationTitleFromSubdomain(subdomain),
+        cleanText(input.description, 500),
+        requiredIdempotencyKey(input.idempotencyKey),
+        now,
+        now
+      ]
+    });
+  } catch (error) {
+    const replay = await getCommonsPublicationForOwner(userId);
+    if (replay?.subdomain === subdomain) return { publication: replay, idempotentReplay: true };
+    throw error;
+  }
+  const publication = await getCommonsPublicationBySubdomain(subdomain);
+  if (!publication) throw new CommonsPublicationError("publication_claim_failed", "The publication claim was not persisted.");
+  return { publication, idempotentReplay: false };
+}
+async function publishCommonsEditorial(input, user) {
+  await ensureCommonsSchema();
+  const subdomain = normalizePublicationSubdomain(input.publicationSubdomain);
+  const publication = await getCommonsPublicationBySubdomain(subdomain);
+  if (!publication) throw new CommonsPublicationError("publication_not_found", "Claim this publication name before publishing an edition.", 404);
+  if (publication.ownerUserId !== Number(user.id)) {
+    throw new CommonsPublicationError("publication_not_owned", "Only the account that claimed this publication can publish to it.", 404);
+  }
+  const idempotencyKey3 = requiredIdempotencyKey(input.idempotencyKey);
+  const replay = await getEditionByIdempotency(Number(user.id), idempotencyKey3);
+  if (replay) return publicationResult(publication, replay, true);
+  const editionSlug = normalizeEditionSlug(input.editionSlug || input.site.slug);
+  const latest = await getLatestEdition(publication.id, editionSlug);
+  if (latest && input.baseRevision === void 0) {
+    throw new CommonsPublicationError("publication_base_revision_required", `Edition ${editionSlug} already exists at revision ${latest.revision}; supply baseRevision to edit it.`, 409);
+  }
+  if (latest && input.baseRevision !== latest.revision) {
+    throw new CommonsPublicationError("publication_revision_conflict", `Edition ${editionSlug} is revision ${latest.revision}; refresh it before publishing an edit.`, 409);
+  }
+  const { publicationSubdomain: _publicationSubdomain, editionSlug: _editionSlug, idempotencyKey: _idempotencyKey, baseRevision: _baseRevision, ...editionInput } = input;
+  const canonicalUrl = editionPublicUrl(subdomain, editionSlug);
+  const rendered = renderEditorialReadingRoom(editionInput);
+  const html = addPublicMetadata(rendered.html, canonicalUrl, publication.title);
+  const editionId = `tced_${randomUUID16()}`;
+  const revision = (latest?.revision ?? 0) + 1;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await getDb().batch([
+    {
+      sql: `
+        INSERT INTO commons_publication_editions (
+          id, publication_id, owner_user_id, edition_slug, revision, title, site_json, deck,
+          articles_json, html, filename, sha256, article_count, word_count, bytes, warnings_json,
+          idempotency_key, created_at, published_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      args: [
+        editionId,
+        publication.id,
+        Number(user.id),
+        editionSlug,
+        revision,
+        editionInput.site.title,
+        JSON.stringify(editionInput.site),
+        editionInput.deck,
+        JSON.stringify(editionInput.articles),
+        html,
+        rendered.filename,
+        createHash13("sha256").update(html).digest("hex"),
+        rendered.articleCount,
+        rendered.wordCount,
+        Buffer.byteLength(html),
+        JSON.stringify(rendered.warnings),
+        idempotencyKey3,
+        now,
+        now
+      ]
+    },
+    {
+      sql: "UPDATE commons_publications SET latest_edition_id = ?, updated_at = ? WHERE id = ? AND owner_user_id = ?",
+      args: [editionId, now, publication.id, Number(user.id)]
+    }
+  ], "write");
+  const edition = await getPublicationEditionById(editionId);
+  if (!edition) throw new CommonsPublicationError("publication_publish_failed", "The published edition was not persisted.");
+  return publicationResult({ ...publication, latestEditionId: editionId, updatedAt: now }, edition, false);
+}
+async function getCommonsPublicationBySubdomain(subdomainInput) {
+  await ensureCommonsSchema();
+  const subdomain = normalizePublicationSubdomain(subdomainInput);
+  const result = await getDb().execute({ sql: "SELECT * FROM commons_publications WHERE subdomain = ? LIMIT 1", args: [subdomain] });
+  return result.rows[0] ? rowToPublication(result.rows[0]) : null;
+}
+async function getCommonsPublicationForOwner(userId) {
+  await ensureCommonsSchema();
+  const result = await getDb().execute({ sql: "SELECT * FROM commons_publications WHERE owner_user_id = ? LIMIT 1", args: [userId] });
+  return result.rows[0] ? rowToPublication(result.rows[0]) : null;
+}
+async function listCommonsPublicationEditions(publicationId) {
+  await ensureCommonsSchema();
+  const result = await getDb().execute({
+    sql: `
+      SELECT edition.* FROM commons_publication_editions edition
+      JOIN (
+        SELECT edition_slug, MAX(revision) AS revision
+        FROM commons_publication_editions WHERE publication_id = ? GROUP BY edition_slug
+      ) latest ON latest.edition_slug = edition.edition_slug AND latest.revision = edition.revision
+      WHERE edition.publication_id = ? ORDER BY edition.published_at DESC
+    `,
+    args: [publicationId, publicationId]
+  });
+  const publication = await getPublicationById(publicationId);
+  if (!publication) return [];
+  return result.rows.map((row) => rowToEdition(row, publication.subdomain));
+}
+async function getCommonsPublicationEditionHtml(subdomainInput, editionSlugInput) {
+  const publication = await getCommonsPublicationBySubdomain(subdomainInput);
+  if (!publication) return null;
+  const result = editionSlugInput ? await getDb().execute({
+    sql: "SELECT * FROM commons_publication_editions WHERE publication_id = ? AND edition_slug = ? ORDER BY revision DESC LIMIT 1",
+    args: [publication.id, normalizeEditionSlug(editionSlugInput)]
+  }) : await getDb().execute({
+    sql: "SELECT * FROM commons_publication_editions WHERE id = ? AND publication_id = ? LIMIT 1",
+    args: [publication.latestEditionId || "", publication.id]
+  });
+  if (!result.rows[0]) return null;
+  const record = result.rows[0];
+  return { publication, edition: rowToEdition(record, publication.subdomain), html: String(record.html || "") };
+}
+async function getPublicationById(id) {
+  const result = await getDb().execute({ sql: "SELECT * FROM commons_publications WHERE id = ? LIMIT 1", args: [id] });
+  return result.rows[0] ? rowToPublication(result.rows[0]) : null;
+}
+async function getLatestEdition(publicationId, editionSlug) {
+  const publication = await getPublicationById(publicationId);
+  if (!publication) return null;
+  const result = await getDb().execute({
+    sql: "SELECT * FROM commons_publication_editions WHERE publication_id = ? AND edition_slug = ? ORDER BY revision DESC LIMIT 1",
+    args: [publicationId, editionSlug]
+  });
+  return result.rows[0] ? rowToEdition(result.rows[0], publication.subdomain) : null;
+}
+async function getEditionByIdempotency(userId, idempotencyKey3) {
+  const result = await getDb().execute({
+    sql: `SELECT edition.*, publication.subdomain FROM commons_publication_editions edition JOIN commons_publications publication ON publication.id = edition.publication_id WHERE edition.owner_user_id = ? AND edition.idempotency_key = ? LIMIT 1`,
+    args: [userId, idempotencyKey3]
+  });
+  if (!result.rows[0]) return null;
+  const record = result.rows[0];
+  return rowToEdition(record, String(record.subdomain));
+}
+async function getPublicationEditionById(id) {
+  const result = await getDb().execute({
+    sql: `SELECT edition.*, publication.subdomain FROM commons_publication_editions edition JOIN commons_publications publication ON publication.id = edition.publication_id WHERE edition.id = ? LIMIT 1`,
+    args: [id]
+  });
+  if (!result.rows[0]) return null;
+  const record = result.rows[0];
+  return rowToEdition(record, String(record.subdomain));
+}
+function rowToPublication(row) {
+  const subdomain = String(row.subdomain);
+  return {
+    id: String(row.id),
+    ownerUserId: Number(row.owner_user_id),
+    subdomain,
+    title: String(row.title),
+    description: String(row.description || ""),
+    latestEditionId: row.latest_edition_id ? String(row.latest_edition_id) : null,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    publicUrl: publicationPublicUrl(subdomain),
+    archiveUrl: `${publicationPublicUrl(subdomain)}/archive`
+  };
+}
+function rowToEdition(row, subdomain) {
+  const editionSlug = String(row.edition_slug);
+  return {
+    id: String(row.id),
+    publicationId: String(row.publication_id),
+    editionSlug,
+    revision: Number(row.revision),
+    title: String(row.title),
+    site: parseJson4(row.site_json, {}),
+    deck: String(row.deck),
+    filename: String(row.filename),
+    sha256: String(row.sha256),
+    articleCount: Number(row.article_count),
+    wordCount: Number(row.word_count),
+    bytes: Number(row.bytes),
+    warnings: parseJson4(row.warnings_json, []),
+    createdAt: String(row.created_at),
+    publishedAt: String(row.published_at),
+    publicUrl: editionPublicUrl(subdomain, editionSlug)
+  };
+}
+function publicationResult(publication, edition, idempotentReplay) {
+  return {
+    publication,
+    edition,
+    publicUrl: publication.publicUrl,
+    archiveUrl: publication.archiveUrl,
+    editionUrl: edition.publicUrl,
+    idempotentReplay
+  };
+}
+function normalizePublicationSubdomain(value) {
+  const normalized = String(value || "").trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!/^[a-z0-9](?:[a-z0-9-]{1,48}[a-z0-9])$/.test(normalized)) {
+    throw new CommonsPublicationError("publication_name_invalid", "Choose a publication name between 3 and 50 characters using letters, numbers, and interior hyphens.");
+  }
+  if (RESERVED_SUBDOMAINS.has(normalized)) throw new CommonsPublicationError("publication_name_reserved", "That publication name is reserved; choose a more specific name.", 409);
+  return normalized;
+}
+function normalizeEditionSlug(value) {
+  const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 80);
+  if (!normalized) throw new CommonsPublicationError("edition_slug_invalid", "A published edition needs a stable slug.");
+  return normalized;
+}
+function requiredIdempotencyKey(value) {
+  const normalized = cleanText(value, 200);
+  if (normalized.length < 8) throw new CommonsPublicationError("idempotency_key_invalid", "Use an idempotency key of at least 8 characters and reuse it only when retrying the same write.");
+  return normalized;
+}
+function publicationPublicUrl(subdomain) {
+  return `https://${subdomain}.${PUBLICATION_ROOT_DOMAIN}`;
+}
+function editionPublicUrl(subdomain, editionSlug) {
+  return `${publicationPublicUrl(subdomain)}/editions/${encodeURIComponent(editionSlug)}`;
+}
+function publicationTitleFromSubdomain(subdomain) {
+  return subdomain.split("-").map((part) => part ? `${part[0]?.toUpperCase()}${part.slice(1)}` : "").join(" ");
+}
+function cleanText(value, max) {
+  return String(value || "").replace(/\s+/g, " ").trim().slice(0, max);
+}
+function parseJson4(value, fallback) {
+  try {
+    return JSON.parse(String(value || ""));
+  } catch {
+    return fallback;
+  }
+}
+function addPublicMetadata(html, canonicalUrl, publicationTitle) {
+  const escapedUrl = canonicalUrl.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  const escapedTitle = publicationTitle.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  return html.replace("</head>", [
+    `  <link rel="canonical" href="${escapedUrl}">`,
+    `  <meta property="og:url" content="${escapedUrl}">`,
+    `  <meta property="og:site_name" content="${escapedTitle}">`,
+    '  <meta name="robots" content="index,follow">',
+    "</head>"
+  ].join("\n"));
+}
+
 // src/api/commons-routes.ts
 var commonsApp = new Hono31();
 var auth2 = createApiKeyAuth();
@@ -32645,10 +33303,83 @@ var NeedsLinkBodySchema = z32.object({
   limit: z32.number().int().min(1).max(100).optional(),
   offset: z32.number().int().min(0).max(1e4).optional()
 }).strict();
+var PreparePublicationSchema = z32.object(CommonsPreparePublicationInputSchema).strict();
+var ValidatePublicationSchema = z32.object(CommonsValidatePublicationInputSchema).strict();
+var ClaimPublicationSchema = z32.object(CommonsClaimPublicationInputSchema).strict();
+var PublishEditorialSchema = z32.object(CommonsPublishEditorialInputSchema).strict();
 commonsApp.get("/health", async (c) => {
   await ensureCommonsSchema();
   return c.json({ ok: true, data: commonsDatabaseReport() });
 });
+commonsApp.post("/publications/prepare", auth2, async (c) => {
+  const parsed = PreparePublicationSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return validationError(c, parsed.error);
+  return publicationOperation(c, () => prepareCommonsPublication(parsed.data, c.get("user")));
+});
+commonsApp.post("/publications/validate", auth2, async (c) => {
+  const parsed = ValidatePublicationSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return validationError(c, parsed.error);
+  return publicationOperation(c, () => validateCommonsPublication(parsed.data, c.get("user")));
+});
+commonsApp.post("/publications/claim", auth2, async (c) => {
+  const parsed = ClaimPublicationSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return validationError(c, parsed.error);
+  return publicationOperation(c, () => claimCommonsPublication(parsed.data, c.get("user")), 201);
+});
+commonsApp.post("/publications/publish", auth2, async (c) => {
+  const parsed = PublishEditorialSchema.safeParse(await c.req.json().catch(() => ({})));
+  if (!parsed.success) return validationError(c, parsed.error);
+  return publicationOperation(c, () => publishCommonsEditorial(parsed.data, c.get("user")), 201);
+});
+commonsApp.get("/publications/me", auth2, async (c) => {
+  const publication = await getCommonsPublicationForOwner(Number(c.get("user").id));
+  if (!publication) return c.json({ ok: false, error: "publication_not_found", message: "This account has not claimed a Commons publication yet." }, 404);
+  const editions = c.req.query("includeEditions") === "false" ? [] : await listCommonsPublicationEditions(publication.id);
+  return c.json({ ok: true, data: { publication, editions } });
+});
+commonsApp.get("/publications/:subdomain/site", async (c) => {
+  try {
+    const result = await getCommonsPublicationEditionHtml(c.req.param("subdomain"));
+    if (!result) return c.json({ ok: false, error: "publication_not_published", message: "No published edition exists for this publication." }, 404);
+    return c.html(result.html, 200, {
+      "cache-control": "public, max-age=60, s-maxage=300",
+      "x-robots-tag": "index, follow"
+    });
+  } catch (error) {
+    return publicationError(c, error);
+  }
+});
+commonsApp.get("/publications/:subdomain/editions/:editionSlug/site", async (c) => {
+  try {
+    const result = await getCommonsPublicationEditionHtml(c.req.param("subdomain"), c.req.param("editionSlug"));
+    if (!result) return c.json({ ok: false, error: "edition_not_found", message: "No published edition matched that publication and slug." }, 404);
+    return c.html(result.html, 200, {
+      "cache-control": "public, max-age=60, s-maxage=300",
+      "x-robots-tag": "index, follow"
+    });
+  } catch (error) {
+    return publicationError(c, error);
+  }
+});
+commonsApp.get("/publications/:subdomain/editions", async (c) => {
+  try {
+    const publication = await getCommonsPublicationBySubdomain(c.req.param("subdomain"));
+    if (!publication) return c.json({ ok: false, error: "publication_not_found", message: "No Commons publication matched that name." }, 404);
+    return c.json({ ok: true, data: { publication, editions: await listCommonsPublicationEditions(publication.id) } });
+  } catch (error) {
+    return publicationError(c, error);
+  }
+});
+commonsApp.get("/publications/:subdomain", async (c) => {
+  try {
+    const publication = await getCommonsPublicationBySubdomain(c.req.param("subdomain"));
+    if (!publication) return c.json({ ok: false, error: "publication_not_found", message: "No Commons publication matched that name." }, 404);
+    const editions = c.req.query("includeEditions") === "false" ? [] : await listCommonsPublicationEditions(publication.id);
+    return c.json({ ok: true, data: { publication, editions } });
+  } catch (error) {
+    return publicationError(c, error);
+  }
+});
 commonsApp.get("/entities", async (c) => {
   const result = await searchCommonsEntities(filtersFromQuery(c.req.query()));
   return c.json({ ok: true, data: result });
@@ -32685,10 +33416,22 @@ commonsApp.post("/entities/validate", auth2, async (c) => {
 commonsApp.post("/entities/propose", auth2, async (c) => {
   const parsed = SubmitEntitySchema.safeParse(await c.req.json().catch(() => ({})));
   if (!parsed.success) return validationError(c, parsed.error);
+  let billing = null;
   try {
+    const user = c.get("user");
+    const kind = await classifyCommonsWrite(parsed.data, user);
+    const charged = await chargeListingWrite({
+      surface: "transparent_commons",
+      kind,
+      userId: Number(user.id),
+      idempotencyKey: parsed.data.idempotencyKey
+    });
+    if ("insufficient" in charged) return c.json(charged.insufficient, 402);
+    billing = charged;
     const result = await submitCommonsEntity(parsed.data, c.get("user"));
-    return c.json({ ok: true, data: result }, result.applied ? 201 : 202);
+    return c.json({ ok: true, data: result, billing: publicListingWriteBilling(billing) }, result.applied ? 201 : 202);
   } catch (error) {
+    if (billing) await refundListingWrite(billing, "Transparent Commons write failed before persistence.").catch(() => null);
     if (error instanceof CommonsRepositoryError) {
       return c.json({ ok: false, error: error.code, message: error.message }, repositoryStatus(error));
     }
@@ -32798,6 +33541,19 @@ function repositoryStatus(error) {
   if (error.httpStatus === 409) return 409;
   return 400;
 }
+async function publicationOperation(c, operation, successStatus = 200) {
+  try {
+    return c.json({ ok: true, data: await operation() }, successStatus);
+  } catch (error) {
+    return publicationError(c, error);
+  }
+}
+function publicationError(c, error) {
+  if (error instanceof CommonsPublicationError) {
+    return c.json({ ok: false, error: error.code, message: error.message }, error.httpStatus);
+  }
+  throw error;
+}
 function xmlEscape(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
 }
@@ -32807,13 +33563,13 @@ import { Hono as Hono32 } from "hono";
 import { z as z33 } from "zod";
 
 // src/api/scheduled-artifact-owner.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function scheduledArtifactOwnerIdForApiKey(apiKey) {
-  return createHash13("sha256").update(apiKey).digest("hex").slice(0, 24);
+  return createHash14("sha256").update(apiKey).digest("hex").slice(0, 24);
 }
 
 // src/api/scheduled-run-view-links.ts
-import { createHash as createHash14, randomBytes as randomBytes3, randomUUID as randomUUID16 } from "crypto";
+import { createHash as createHash15, randomBytes as randomBytes3, randomUUID as randomUUID17 } from "crypto";
 var schemaReady3 = false;
 async function ensureScheduledRunViewLinksSchema() {
   if (schemaReady3) return;
@@ -32844,7 +33600,7 @@ async function ensureScheduledRunViewLinksSchema() {
   schemaReady3 = true;
 }
 function tokenHash2(token4) {
-  return createHash14("sha256").update(token4).digest("hex");
+  return createHash15("sha256").update(token4).digest("hex");
 }
 function mapRow(row) {
   return {
@@ -32866,7 +33622,7 @@ async function createScheduledRunViewLink(input) {
   const now = input.now ?? /* @__PURE__ */ new Date();
   const token4 = randomBytes3(32).toString("base64url");
   const record = {
-    shareId: randomUUID16(),
+    shareId: randomUUID17(),
     ownerId: input.ownerId,
     runId: input.runId,
     artifactId: input.artifactId,
@@ -33103,7 +33859,7 @@ scheduledResultApp.delete("/schedule-runs/:runId/view-links/:shareId", async (c)
 import { Hono as Hono33 } from "hono";
 
 // src/scheduled-artifacts/scheduled-run-artifact-store.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 var SCHEDULED_RUN_ARTIFACT_PREFIX = "scheduled-run-artifacts/";
 var SCHEDULED_RUN_ARTIFACT_DOWNLOAD_TTL_MS = 15 * 60 * 1e3;
 var SCHEDULED_RUN_ARTIFACT_MAX_BYTES = 2e6;
@@ -33119,7 +33875,7 @@ function policy3() {
   };
 }
 function runStorageSegment(runId) {
-  return /^[a-zA-Z0-9_-]{1,160}$/.test(runId) ? runId : `run-${createHash15("sha256").update(runId).digest("hex").slice(0, 32)}`;
+  return /^[a-zA-Z0-9_-]{1,160}$/.test(runId) ? runId : `run-${createHash16("sha256").update(runId).digest("hex").slice(0, 32)}`;
 }
 async function createScheduledRunArtifact(args) {
   if (args.rendered.bytes > SCHEDULED_RUN_ARTIFACT_MAX_BYTES) {
@@ -33226,10 +33982,10 @@ publicScheduledResultApp.get("/scheduled-run-view-links/:token/content", async (
 import { Hono as Hono34 } from "hono";
 
 // src/api/scheduler-integration-auth.ts
-import { createHash as createHash16, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash17, createHmac as createHmac4, timingSafeEqual as timingSafeEqual3 } from "crypto";
 
 // src/api/service-connections.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 var schemaReady4 = null;
 var schemaDb3 = null;
 function ensureServiceConnectionsSchema() {
@@ -33371,7 +34127,7 @@ async function reconcileDiscoveredNangoConnections(identity, discovered) {
           updated_at = excluded.updated_at
       `,
       args: [
-        randomUUID17(),
+        randomUUID18(),
         userId,
         connection.providerConfigKey,
         connection.provider,
@@ -33442,7 +34198,7 @@ async function recordServiceConnectionHealth(args) {
   });
   await getDb().execute({
     sql: `INSERT INTO service_connection_health_events (id, connection_id, operational_status, failure_code, retryable, evidence_source) VALUES (?, ?, ?, ?, ?, ?)`,
-    args: [randomUUID17(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
+    args: [randomUUID18(), args.connectionId, args.operationalStatus, args.failureCode ?? null, args.retryable == null ? null : args.retryable ? 1 : 0, args.evidenceSource]
   });
 }
 async function setServiceConnectionActions(identity, connectionId, enabled) {
@@ -33482,7 +34238,7 @@ async function claimServiceConnectionAction(args) {
   if (!connection) throw new Error("service_connection_not_found");
   const inserted = await getDb().execute({
     sql: `INSERT OR IGNORE INTO service_connection_action_audit (id, connection_id, user_id, tool, request_id, status, request_digest) VALUES (?, ?, ?, ?, ?, 'started', ?)`,
-    args: [randomUUID17(), connection.id, connection.userId, args.tool, args.requestId, args.requestDigest]
+    args: [randomUUID18(), connection.id, connection.userId, args.tool, args.requestId, args.requestDigest]
   });
   if (Number(inserted.rowsAffected ?? 0) === 1) return { claimed: true };
   const existing = await getDb().execute({
@@ -33524,7 +34280,7 @@ function signingSecret() {
   return secret2;
 }
 function schedulerIntegrationSignature(args) {
-  const bodyHash = createHash16("sha256").update(args.body).digest("hex");
+  const bodyHash = createHash17("sha256").update(args.body).digest("hex");
   return createHmac4("sha256", args.secret).update(`${args.method.toUpperCase()}
 ${args.path}
 ${args.timestamp}
@@ -33808,13 +34564,13 @@ async function reconcileSiteExtractSettlements(limit = 25) {
 }
 
 // src/api/page-diff.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { diffLines } from "diff";
 var MAX_SNAPSHOT_CONTENT_CHARS = 25e4;
 var MAX_DIFF_HUNKS = 200;
 var MAX_DIFF_LINES_PER_RESPONSE = 2e3;
 function sha256Hex(value) {
-  return createHash17("sha256").update(value).digest("hex");
+  return createHash18("sha256").update(value).digest("hex");
 }
 function truncateForStorage(value, maxChars = MAX_SNAPSHOT_CONTENT_CHARS) {
   if (value.length <= maxChars) return { value, truncated: false };
@@ -33928,10 +34684,10 @@ async function persistScrapeBody(user, opts) {
 }
 
 // src/api/scrape-image-sink.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 var MAX_IMAGES_PER_SCRAPE = 25;
 function idempotencyKey2(userId, vault, input) {
-  return `scrape-image-${createHash18("sha256").update(`${userId}\0${vault}\0${input.sourceKind}\0${input.sourceUrl}\0${input.imageUrl ?? ""}\0${input.imageBase64 ?? ""}`).digest("hex")}`;
+  return `scrape-image-${createHash19("sha256").update(`${userId}\0${vault}\0${input.sourceKind}\0${input.sourceUrl}\0${input.imageUrl ?? ""}\0${input.imageBase64 ?? ""}`).digest("hex")}`;
 }
 async function persistScrapeImagesToMemory(user, inputs, vault) {
   const selected = inputs.slice(0, MAX_IMAGES_PER_SCRAPE);
@@ -34403,7 +35159,7 @@ function inferredWaybackCapturedAt(content) {
 }
 
 // src/api/connection-memory-import.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 var CONNECTION_MEMORY_IMPORT_MAX_ARGS_BYTES = 64 * 1024;
 var CONNECTION_MEMORY_IMPORT_MAX_RESULT_BYTES = 1e6;
 var CONNECTION_MEMORY_IMPORT_MAX_STRING_CHARS = 256e3;
@@ -34433,7 +35189,7 @@ function canonicalJson(value) {
   return JSON.stringify(value);
 }
 function sha2562(value) {
-  return createHash19("sha256").update(value).digest("hex");
+  return createHash20("sha256").update(value).digest("hex");
 }
 function sensitiveKey(key) {
   const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -34702,7 +35458,7 @@ async function cleanupExpiredScrapeBlobs(maxAgeMs = SCRAPE_BLOB_TTL_MS) {
 }
 
 // src/api/connected-data-export.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 var CONNECTED_DATA_INLINE_BUDGET_BYTES = Number(
   process.env.MCP_SCRAPER_CONNECTED_DATA_INLINE_BUDGET_BYTES ?? 5e4
 );
@@ -34873,7 +35629,7 @@ function finitePositive(value, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback;
 }
 async function collectConnectedDataExport(args) {
-  const exportId = randomUUID18();
+  const exportId = randomUUID19();
   const now = args.now ?? Date.now;
   const startedAt = now();
   const budgetMs = finitePositive(CONNECTED_DATA_EXPORT_BUDGET_MS, 24e4);
@@ -34989,7 +35745,7 @@ ${lines.length ? `${lines.join("\n")}
 }
 
 // src/api/search-console-table-export.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 var SEARCH_CONSOLE_TABLE_EXPORT_MAX_ROWS = 5e4;
 var SEARCH_CONSOLE_TABLE_EXPORT_PAGE_SIZE = 2e3;
 var SEARCH_CONSOLE_TABLE_EXPORT_MAX_BYTES = 50 * 1024 * 1024;
@@ -35089,7 +35845,7 @@ async function exportSearchConsoleTableData(args) {
     offset += rows.length;
     if (stoppedForBytes || rows.length < limit || offset >= matchedRows) break;
   }
-  const exportId = randomUUID19();
+  const exportId = randomUUID20();
   const artifact = await args.writeArtifact({
     ownerId: args.ownerId,
     exportId,
@@ -35444,7 +36200,7 @@ async function dbUsage(identity, plan) {
 }
 
 // src/api/nango-control.ts
-import { createHash as createHash21, randomUUID as randomUUID21 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID22 } from "crypto";
 
 // src/api/slack-archive-analysis.ts
 function isRecord2(value) {
@@ -35818,7 +36574,7 @@ async function exportSlackChannelPage(input, dependencies) {
 }
 
 // src/api/main-nango-transport.ts
-import { createHash as createHash20, randomUUID as randomUUID20 } from "crypto";
+import { createHash as createHash21, randomUUID as randomUUID21 } from "crypto";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 
 // src/api/connected-tool-policy.ts
@@ -36211,7 +36967,7 @@ async function listNangoToolsDirect(identity, connectionId) {
   });
   const readTools = [...policies.values()].filter((policy4) => policy4.classification === "read").map((policy4) => policy4.name);
   const actionTools = [...policies.values()].filter((policy4) => policy4.classification === "action").map((policy4) => policy4.name);
-  const revision = createHash20("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
+  const revision = createHash21("sha256").update(JSON.stringify(tools.map((tool) => ({ name: tool.name, inputSchema: tool.inputSchema })))).digest("hex");
   await updateServiceConnectionTools(connection.id, readTools, actionTools, revision);
   const refreshed = await getOwnedServiceConnection(identity, connection.id);
   return { connection: refreshed ?? { ...connection, readTools, actionTools, toolRevision: revision }, tools };
@@ -36238,8 +36994,8 @@ async function callNangoToolDirect(args) {
     identity: args.identity,
     ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION
   });
-  const requestId = args.requestId?.trim() || randomUUID20();
-  const idempotencyKey3 = `main-nango:${createHash20("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
+  const requestId = args.requestId?.trim() || randomUUID21();
+  const idempotencyKey3 = `main-nango:${createHash21("sha256").update(args.identity.toLowerCase()).update("\0").update(connection.id).update("\0").update(args.tool).update("\0").update(requestId).digest("hex")}`;
   const startedAt = /* @__PURE__ */ new Date();
   const started = performance.now();
   let result;
@@ -36264,7 +37020,7 @@ async function callNangoToolDirect(args) {
       toolName: args.tool,
       operationKind: args.operationKind ?? args.classification,
       outcome: providerError ? "error" : "partial",
-      requestId: requestId.length <= 200 ? requestId : createHash20("sha256").update(requestId).digest("hex"),
+      requestId: requestId.length <= 200 ? requestId : createHash21("sha256").update(requestId).digest("hex"),
       startedAt: startedAt.toISOString(),
       completedAt: completedAt.toISOString()
     }
@@ -36306,7 +37062,7 @@ async function describeNangoToolDirect(identity, connectionId, toolName) {
     providerContractHash: MAIN_INTEGRATION_CONTRACT_HASH,
     protocolVersion: null,
     schemaSource: "live_tools_list",
-    schemaHash: createHash20("sha256").update(JSON.stringify(projected)).digest("hex"),
+    schemaHash: createHash21("sha256").update(JSON.stringify(projected)).digest("hex"),
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -37030,8 +37786,8 @@ async function setScheduleConnectionActionsEnabled(identity, connectionId, enabl
   return data.connection.actionsEnabled === true;
 }
 async function callScheduleConnectionAction(identity, connectionId, input, tool, idempotencyKey3) {
-  const requestId = `main-connected-action:${createHash21("sha256").update(identity).update("\0").update(idempotencyKey3?.trim() || randomUUID21()).digest("hex")}`;
-  const requestDigest = createHash21("sha256").update(connectionId).update("\0").update(tool?.trim() ?? "").update("\0").update(canonicalJson2(input)).digest("hex");
+  const requestId = `main-connected-action:${createHash22("sha256").update(identity).update("\0").update(idempotencyKey3?.trim() || randomUUID22()).digest("hex")}`;
+  const requestDigest = createHash22("sha256").update(connectionId).update("\0").update(tool?.trim() ?? "").update("\0").update(canonicalJson2(input)).digest("hex");
   if (mainOwnsIntegrations()) {
     const selectedTool = tool?.trim();
     if (!selectedTool) throw new NangoControlError("An action tool is required.", 400, "invalid_request", false);
@@ -37182,7 +37938,7 @@ function canonicalJson2(value) {
   return JSON.stringify(value);
 }
 function projectedToolSchemaHash(tool) {
-  return createHash21("sha256").update(canonicalJson2(tool)).digest("hex");
+  return createHash22("sha256").update(canonicalJson2(tool)).digest("hex");
 }
 async function describeNangoTool(identity, connectionId, tool, fresh) {
   if (mainOwnsIntegrations()) {
@@ -37461,7 +38217,7 @@ async function callMainOwnedExportPage(identity, input) {
 }
 
 // src/api/resend-control.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 var DEFAULT_CONNECTION_CONTROL_URL = "https://mcp-scraper-scheduler.vercel.app";
 var RESEND_PROVIDER_CONFIG_KEY = "resend";
 var RESEND_LOGO_URL = "https://cdn.resend.com/brand/resend-icon-black.svg";
@@ -37720,7 +38476,7 @@ async function callResendRead(identity, connectionId, tool, args) {
   return isRecord5(data) ? data.result ?? data : data;
 }
 async function callResendAction(identity, connectionId, tool, input, idempotencyKey3) {
-  const requestId = `main-resend-action:${createHash22("sha256").update(identity).update("\0").update(idempotencyKey3.trim()).digest("hex")}`;
+  const requestId = `main-resend-action:${createHash23("sha256").update(identity).update("\0").update(idempotencyKey3.trim()).digest("hex")}`;
   const body = await controlRequest2("/api/internal/resend/actions/call", {
     method: "POST",
     headers: { "x-request-id": requestId },
@@ -39554,7 +40310,7 @@ app.post("/harvest", auth3, async (c) => {
     if (!harvestOk) return c.json(insufficientBalanceResponse(harvestBal, harvestCost), 402);
     jobId2 = await createJob(user.id, options.query, { ...options, billingHoldMc: harvestCost }, body.callback_url);
   } else {
-    jobId2 = randomUUID22();
+    jobId2 = randomUUID23();
     const billingDebitKey = `paa-harvest:${jobId2}:hold`;
     const description = `PAA harvest: ${options.query}`.slice(0, 500);
     const hold = await debitMcIdempotent(
@@ -40772,7 +41528,7 @@ app.get("/cron/tick", async (c) => {
   if (!process.env.CRON_SECRET || secret2 !== `Bearer ${process.env.CRON_SECRET}`) {
     return c.json({ error: "Unauthorized" }, 401);
   }
-  const { drainQueue } = await import("./worker-73AYU4IK.js");
+  const { drainQueue } = await import("./worker-4LZGRHDA.js");
   const budget = { maxJobs: 10, deadlineMs: Date.now() + 28e4 };
   const workflowDispatchResult = await dispatchDueWorkflowSchedules(`${new URL(c.req.url).protocol}//${new URL(c.req.url).host}`);
   const [results, sweepResult, reapResult, expiredResult, blobCleanup, connectedDataArtifactCleanup, connectedAccountBilling, directoryWorkflowDispatch, directoryWorkflowReconciliation, directoryArtifactCleanup, siteExtractArtifactCleanup, siteExtractRedispatch, siteExtractReconciliation, paaHarvestRedispatch, paaHarvestReconciliation, localSourcebookRedispatch] = await Promise.all([
@@ -40827,8 +41583,8 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
     finishExtractJob: finishExtractJob2,
     terminalExtractJobStatus: terminalExtractJobStatus2,
     extractJobLimitInfo: extractJobLimitInfo2
-  } = await import("./site-extract-repository-CKCJDP7N.js");
-  const { assembleExtractArtifacts } = await import("./extract-bundle-U3MNYDKC.js");
+  } = await import("./site-extract-repository-G723PZIL.js");
+  const { assembleExtractArtifacts } = await import("./extract-bundle-DYMQRQWG.js");
   const existing = await getExtractJob2(jobId2);
   if (!existing) return c.json({ error: "job not found" }, 404);
   if (existing.status !== "failed") {
@@ -40855,7 +41611,7 @@ app.post("/api/internal/extract-refinalize/:id", async (c) => {
   if (!updated) return c.json({ error: "job state changed during re-finalization" }, 409);
   let settlement = "already_settled_or_refunded";
   if (job.billedMc == null && job.userId != null) {
-    const { settleExtractJob: settleExtractJob3, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-CKCJDP7N.js");
+    const { settleExtractJob: settleExtractJob3, countSuccessfulPages: countSuccessfulPages2 } = await import("./site-extract-repository-G723PZIL.js");
     const heldMc = Number(job.options.heldMc ?? 0);
     const successful = await countSuccessfulPages2(jobId2);
     const usedMc = Math.min(successful * MC_COSTS.page_scrape, heldMc);
@@ -41039,4 +41795,4 @@ app.get("/blog/:slug/", (c) => {
 export {
   app
 };
-//# sourceMappingURL=server-W4JLSNKW.js.map
+//# sourceMappingURL=server-SMEHT3OU.js.map