@hypersoniclabs/helix-cli 0.1.7 → 0.1.24-helix3.438

package/dist/lib.d.ts

@@ -1,18 +1,115 @@
-import { HelixApi } from './api';
+import { capturePublishThumbnail } from './screenshot/publishThumbnail';
+export { WORLD_THUMBNAIL_PUBLICATION_VERSION } from './screenshot/publishThumbnail';
+import { HelixApi, uploadToTicket } from './api';
+export { createPlacementRequest, validatePlacementRequest, placementRequestBundleFile, writePlacementRequest, PLACEMENT_REQUEST_FILENAME } from './placementRequest';
+import { loadVendoredValidator } from './ability';
+import { type AchievementCriteria, type AchievementRegistrationFields, type AchievementRegistrationInput, type AchievementUpdateInput } from './achievement';
+import { type ProductGrant, type ProductRegistrationFields, type ProductRegistrationInput, type ProductUpdateInput } from './product';
+import { type ItemDistributionInput, type ItemDistributionUpdateInput } from './distribution';
 import { CliCredentials } from './config';
+import { type RealizabilityDeps } from './realizability';
 export { ApiError, HelixApi, uploadToTicket } from './api';
-export { checkBundle, multiplayerConfigBundleFile, MULTIPLAYER_CONFIG_FILENAME, type BundleCheck, type BundleFile, } from './bundle';
+export { checkHostAddOns, checkPublishedAddOn, formatHostAddOns, formatPublishedVerdict, publicRequester, type HostAddOnsReport, type PublishedAddOnVerdict, } from './vehicle/addonPublished';
+export { bakePlacements } from './placements/bake';
+export { bakeTreeImpostors, type BakeTreeImpostorsOptions } from './placements/impostors';
+export { attachTreeImpostors } from './placements/attachImpostors';
+export { readPlacementsBake, inspectPlacementsBake, placementsBundle, placementsContinuum } from './placements/source';
+export { DEVICE_FILENAME, createDeviceProject, readDeviceGlbNodeNames, testDeviceProject, validateDeviceProject, type DeviceTestReport, type DeviceValidationReport, } from './device';
+export { checkBundle, tiledTerrainBakedLightingWarning, PLATFORM_THREE_VERSION, multiplayerConfigBundleFile, MULTIPLAYER_CONFIG_FILENAME, type BundleCheck, type BundleFile, } from './bundle';
 export { checkPackageBundle, type PackageBundleCheck } from './package';
+export { PRIVATE_BUILD_DRAFT_SCHEMA, createPrivateBuildDraft, freezeBuildDraft, frozenBuildArtifactKey, type BuildDraft, type BuildDraftInput, type BuildFreezeInput, type BuildFreezeResult, type FrozenBuild, } from './builds';
+export { addInteractable, composeInteractableModuleManifest, composeInteractableManifest, interactableModuleId, instanceOrdinalOf, moduleInteractableFragment, namespaceInteractableFragment, parseInteractablePosition, subtractInteractableContribution, updateInteractable, type AddInteractableDeps, type AddInteractableResult, type InteractableCapsReport, type InteractableModuleContribution, type InteractablePlacementTransform, type UpdateInteractableResult, } from './interactable';
+export { labelModuleValidationErrors } from './module-validation';
+export * as terrain from './terrain/index';
+export * as cs2 from './cs2/index';
+export { compileSceneElements, compileSceneElementsBundle, type CompileSceneElementsOptions, type SceneBundleFile, type SceneElementsCompilation, } from './sceneElements/compiler';
+export { CONTINUUM_SCENE_DOCUMENT_MEDIA_TYPE, compileContinuumScenePackage, type SceneCompilationReport, type ScenePackageCompilation, type ScenePackageCompilationInput, } from './sceneElements/continuum';
+export type { ArchitecturalElement, BoxElement, BuildingElement, CascadingElementProperties, ContainerElement, ElementMaterial, ElementStreamPolicy, GroupElement, LegacyBuildingElement, LevelElement, LightElement, PointLightElement, SceneElement, SceneElementRole, SceneElementsDocument, SceneDeviceDefinitionAuthoring, SceneDeviceInstanceAuthoring, SceneDeviceLinkAuthoring, SceneDevicePackagePin, SceneDevicesAuthoring, SlabElement, SpaceElement, SpotLightElement, TerrainElement, WallElement, } from './sceneElements/types';
+export { HELIX_OFFICIAL_MATERIAL_SUBSET, MATERIAL_AUTO_REPLACE_CONFIDENCE, MATERIAL_REVIEW_CONFIDENCE, buildMaterialBulkRecipe, buildMaterialPackageRecipe, createSharedMaterialBinding, matchCanonicalMaterial, type CanonicalMaterialArtifactInput, type CanonicalMaterialCatalogEntry, type CanonicalMaterialFamily, type MaterialMatch, type MaterialMatchAlternative, type MaterialPackageRecipe, type MaterialPackageRecipeInput, type SharedMaterialBindingInput, type SourceMaterialDescription, } from './sceneImport/materials';
+export { NATIVE_SCENE_CONVERSION_CONFIDENCE, SOURCE_SCENE_IMPORT_BUDGETS, importSourceSceneMap, type SourceNativeCandidate, type SourceSceneActor, type SourceSceneImportReceipt, type SourceSceneImportResult, type SourceSceneMap, type SourceSceneMaterial, } from './sceneImport/semantic';
+export * from './continuum';
+export * from './canary';
+export { analyzeScenePerformance, formatScenePerformanceReport, type ScenePerformanceFinding, type ScenePerformanceOptions, type ScenePerformanceReport, } from './scenePerformance';
+export { collectSourceFiles, createSourceArchive, formatArchiveSize, isSourceExcluded, parseGitignore, SOURCE_ARCHIVE_FILENAME, SOURCE_CONTENT_TYPE, SOURCE_HARD_EXCLUDES, SOURCE_MAX_BYTES, type IgnoreRule, type SourceArchive, type SourceEntry, } from './source-archive';
+export { assertCcGenders, assertCcSlot, assertLooksLikeGlb, CC_GENDERS, CC_WEARABLE_SLOTS, CC_WEARABLE_SLOT_GROUPS, ccGendersAreAllowedForKind, ccGendersAreRequiredForKind, ccSlotIsAllowedForKind, ccSlotIsRequiredForKind, isCcGender, isCcWearableSlot, CLIP_SET_SLOT_TYPES, meshContentTypeFromExtension, normalizeItemKind, parseJsonArrayOrFile, parseJsonObjectOrFile, parseJsonOrFile, parseGenders, parseTags, renderCcGenderList, renderCcSlotTable, type CcGender, type CcWearableSlot, type UploadableItemKind, } from './item';
+export { DISTRIBUTION_KEY_PATTERN, ITEM_DISTRIBUTION_CHANNELS, ITEM_EDITION_MODES, buildItemDistribution, buildItemDistributionUpdate, editionFields, type ItemDistributionChannel, type ItemDistributionFields, type ItemDistributionInput, type ItemDistributionPatch, type ItemDistributionUpdateInput, type ItemEditionMode, } from './distribution';
+export { ACHIEVEMENT_CRITERIA_METRICS, ACHIEVEMENT_CRITERIA_OPS, ACHIEVEMENT_CRITERIA_SIGNALS, ACHIEVEMENT_ICON_MAX_BYTES, ACHIEVEMENT_KEY_PATTERN, ACHIEVEMENT_TROPHY_MAX_BYTES, ACHIEVEMENT_UNLOCK_MODES, DATA_STORE_CRITERIA_KEY_TEMPLATES, buildAchievementCriteria, buildAchievementRegistration, buildAchievementUpdate, formatAchievementCriteria, iconContentTypeFromExtension, isAchievementKey, resolveUnlockMode, type AchievementCriteria, type AchievementCriteriaInput, type AchievementCriteriaMetric, type AchievementCriteriaOp, type AchievementCriteriaSignal, type AchievementRegistrationFields, type AchievementRegistrationInput, type AchievementUnlockMode, type AchievementUpdateInput, } from './achievement';
+export { GRANT_CODE_MAX, GRANT_CODE_PATTERN, MAX_GRANT_CURRENCY_AMOUNT, MAX_GRANT_EFFECTS, MAX_GRANT_ITEM_QUANTITY, MAX_PASS_DURATION_SECONDS, PRODUCT_DESCRIPTION_MAX, PRODUCT_KEY_MAX, PRODUCT_KEY_PATTERN, PRODUCT_TITLE_MAX, WORLD_PRODUCT_TYPES, buildProductRegistration, buildProductUpdate, isProductKey, productTypeGrantsItem, type ProductGrant, type ProductGrantDisplay, type ProductPatch, type ProductRegistrationFields, type ProductRegistrationInput, type ProductUpdateInput, type WorldProductType, } from './product';
 export { checkAbilityBundle, installLocalAbility, loadVendoredValidator, loadInstalledIndexValidator, type AbilityValidator, } from './ability';
-export { normalizePinRange, resolvePins, type PinMap, type ResolveDeps, type ResolvedPackage, type ResolvedPins, type VersionDetail, type WorldPins, } from './resolve';
-export { installWorld, INSTALLED_INDEX, LOCKFILE, MODULES_DIR, type InstalledEntry, type InstallDeps, type InstallWorldOptions, type InstallWorldResult, type WorldLock, } from './install';
+export { normalizePinRange, validateAssetPackConstraints, resolvePins, type PinMap, type ResolveDeps, type ResolvedPackage, type ResolvedPins, type VersionDetail, type WorldPins, } from './resolve';
+export { installWorld, INSTALLED_INDEX, LOCKFILE, MODULES_DIR, WORLD_MANIFEST_LOCATIONS, type InstalledEntry, type InstallDeps, type InstallWorldOptions, type InstallWorldResult, type WorldLock, } from './install';
+export { ALLOW_EXACT_ENGINE_PIN_FLAG, detectExactEnginePins, enginePinOverrideLogPath, type ExactEnginePin, } from './enginePins';
+export { assessInteractables, assessPlatformDelivery, assessThreeCurrency, assessVaultAssets, assessWeaponPins, assessWorldCurrency, ADVISORY_SYSTEMS, type CatalogClient, type InteractableFinding, type InteractableRow, type PlatformDeliveryStatus, type ThreeCurrency, type ThreeCurrencyFinding, type ThreeCurrencyRow, type VaultAssetFinding, type VaultAssetRow, type VaultResolveApi, type WeaponPinFinding, type WeaponPinRow, type WeaponPinsCurrency, type WorldCurrency, type WorldSystemFinding, type WorldSystemRow, } from './currency';
 export { apiUrlMatchesEnv, credsEnvMismatchWarning, DEFAULT_API_URL, DEFAULT_WEB_URL, HELIX_ENV, HELIX_SCOPE, loadCredentials, saveCredentials, clearCredentials, jwtExpiresAtIso, type CliCredentials, } from './config';
 export { browserLogin, defaultClientTokenName, type BrowserLoginResult } from './browserLogin';
-export { initTemplate } from './init';
+export { initTemplate, slugify, type InitOptions, type InitResult, type WorldKind, } from './init';
 export { initAbilityTemplate } from './initAbility';
+export { checkRealizability, registryRealizabilityDeps, renderRealizabilityRefusal, TICK_NODE_CEILING, type RealizabilityDeps, type RealizabilityFailure, } from './realizability';
+export { getLixBalance, listJobs, formatJobs, type JobSummary, type JobState, quoteGeneration, normalizeQuote, formatBalance, formatQuote, formatLix, formatReceipt, formatWaitState, receiptLix, roundLix, type GenerationQuote, type LixBalance, type LixHold, type QuoteComponent, } from './money';
+export { verifySubPath, formatSubPathResult, DEFAULT_MOUNT_PREFIX, type SubPathFinding, type SubPathRequestEvidence, type SubPathSourceLocation, type VerifySubPathOptions, type VerifySubPathResult, } from './verifySubPath';
+export { approveDreamerGate, describeGateAdvance, extensionFor, formatStrandedJob, generateAndPublishAsset, generateAndPublishAssetFromReference, generateAudio, generateImage, generateStandaloneAsset, getDreamerAssetGenerationJob, getStandaloneAssetGenerationJob, getVaultAsset, getVaultAssetUsage, getVaultAssetVersions, installVaultAsset, listDreamerVoices, listMaterials, MATERIAL_RENDITION_SELECTIONS, resolveMaterial, resumeAndPublishAsset, retryDreamerJob, reviseDreamerGate, saveGeneratedAsset, StrandedJobError, searchVaultAssets, startDreamerAssetGeneration, startDreamerAssetGenerationFromReference, startStandaloneAssetGeneration, updateVaultAssetMetadata, UnavailableCapabilityError, VAULT_ASSET_KINDS, type DreamerApprovalGate, type DreamerAssetJob, type DreamerAssetKind, type DreamerAwaitingApproval, type DreamerGateOption, type DreamerJobStage, type DreamerRecovery, type DreamerRecoveryAction, type DreamerAudioMode, type DreamerAudioVoiceSettings, type DreamerCatalogVoice, type DreamerPipeline, type DreamerVoiceCatalogQuery, type DreamerVoiceCatalogResponse, type DreamerVoiceCategory, type DreamerVoiceLanguage, type GenerateAssetInput, type GenerateAssetFromReferenceInput, type GenerateAssetOptions, type GenerateAudioInput, type GenerateStandaloneAssetInput, type InstalledVaultAsset, type StandaloneGeneratedAsset, type StandaloneAssetKind, type MaterialCatalogEntry, type MaterialCatalogResult, type MaterialRenditionSelection, type MaterialMaps, type MaterialResolutionOption, type MaterialResolutionReport, type MaterialResolutionVariant, type ResolvedMaterial, DEFAULT_RESOLUTION_KEY, materialDefaultResolutionKey, materialResolutionOptions, matchMaterialResolution, type VaultAssetDetail, type VaultAssetKind, type VaultAssetSearch, type VaultAssetSummary, type VaultAssetUsage, type VaultAssetVersion, type VaultMetadataUpdate, type VaultRelatedArtifact, type VaultSelectionExplanation, } from './assets';
+export { materialContinuumIdentity, parseContinuumCurrentVersion, parseVaultMaterialSearch, platformMaterialTag, type MaterialContinuumRef, type MaterialVaultPin, type MaterialVaultResolution, } from './materials/identity';
+export { clearMaterialPinCache, type MaterialPins } from './materials/pins';
 export type { ImportCharacterClipResult, ImportCharacterOptions, ImportCharacterResult, } from './character/importCharacter';
+export type { CapturePose, CaptureScreenshotsOptions, CaptureScreenshotsResult } from './screenshot/captureScreenshots';
+export type { EncodeImagePreviewResult } from './screenshot/encodeImagePreview';
+export type { InspectOptions, InspectResult, InspectAttachSpec, AttachmentReadback, AttachmentPlacement, BoneReadback, MotionReadback, AxisRow, AxisRangeRow } from './gesture/inspect';
+export type { CaptureGestureOptions, CaptureGestureResult } from './gesture/capture';
+export type { BoneAxisReference } from './gesture/axisReference';
+export type { ColliderInfo, ColliderSource, Quat, SnapshotObject, SnapshotOptions, Vec3, WorldSnapshot } from './world/snapshotTypes';
+export type { AnalysisResult, Confidence, Finding, Severity } from './world/analyze';
+export type { ReportSection } from './world/format';
+export type { MovedObject, WorldDiff } from './world/diff';
+export type { SnapshotWorldOptions } from './world/snapshotWorld';
+export type { ZoneAnalysis, ZoneConfig, ZoneReport } from './world/zones';
+export type { WorldMetricsTable } from './world/readWorldMetrics';
+export { auditCookScope, candidateArtifactDigest, defaultIdempotencyKey, planSharedRuntimePublish, UnrealCandidateError, verifyUnrealCandidate, type BackendArtifactRole, type CandidateManifest, type CandidateRole, type CookScopeReport, type PlannedUpload, type SharedRuntimeCreateRequest, type SharedRuntimeNetworkMode, type SharedRuntimePublishPlan, type VerifiedCandidate, } from './unrealCandidate';
+export { assertClientDeliveryMatchesPlan, assertCreateResponseMatchesPlan, assertReceipt, publishUnrealBuild, renderPublishFailure, resolveWorldId, uploadArtifact, type SharedRuntimeBuildReceipt, type SharedRuntimeCreateResponse, type SharedRuntimeUploadTicket, type UnrealPublishOptions, type UnrealPublishResult, } from './unrealPublish';
+export { formatUnrealValidationReport, HELIX_UNREAL_CONTRACT_VERSION, HELIX_UNREAL_ENGINE_VERSION, initUnrealManifest, packageUnrealProject, validateUnrealProject, type UnrealProjectValidationReport, } from './unreal';
 import type { ImportCharacterOptions, ImportCharacterResult } from './character/importCharacter';
+import type { CaptureScreenshotsOptions, CaptureScreenshotsResult } from './screenshot/captureScreenshots';
+import type { EncodeImagePreviewResult } from './screenshot/encodeImagePreview';
+import type { InspectOptions, InspectResult } from './gesture/inspect';
+import type { CaptureGestureOptions, CaptureGestureResult } from './gesture/capture';
+import type { WorldSnapshot } from './world/snapshotTypes';
+import type { SnapshotWorldOptions } from './world/snapshotWorld';
+import type { InspectNpcOptions } from './npc/inspect';
+import type { CaptureNpcOptions, CaptureNpcResult } from './npc/capture';
+import type { NpcInspection } from './npc/metrics';
 export declare function importCharacter(opts: ImportCharacterOptions): Promise<ImportCharacterResult>;
+export declare function captureScreenshots(opts: CaptureScreenshotsOptions): Promise<CaptureScreenshotsResult>;
+export declare function encodeImagePreview(file: string, maxWidth: number): Promise<EncodeImagePreviewResult>;
+export declare function inspectGesture(opts: InspectOptions): Promise<InspectResult>;
+export declare function formatGestureInspection(result: InspectResult, opts?: {
+    motionWindow?: [number, number] | null;
+}): Promise<string>;
+export declare function captureGesture(opts: CaptureGestureOptions): Promise<CaptureGestureResult>;
+export { analyzeWorld, sortFindings } from './world/analyze';
+export { formatWorldInspection, DEFAULT_REPORT } from './world/format';
+export { diffWorldSnapshots, formatWorldDiff } from './world/diff';
+export { analyzeZones } from './world/zones';
+export { formatWorldFocus, resolveFocus } from './world/focus';
+export type { FocusQuery } from './world/focus';
+export { detectInspectWiring, detectNpcWiring } from './world/wiring';
+export type { InspectWiring, NpcWiring } from './world/wiring';
+export { canonicalizeSnapshot } from './world/canonicalize';
+export { applyBaseline, buildBaseline, parseBaseline, anchorOf, BASELINE_FILENAME } from './world/baseline';
+export type { BaselineEntry, BaselineResult, WorldBaseline } from './world/baseline';
+export declare function snapshotWorld(opts: SnapshotWorldOptions): Promise<WorldSnapshot>;
+export declare function inspectNpc(opts: InspectNpcOptions): Promise<NpcInspection>;
+export declare function formatNpcInspection(result: NpcInspection): Promise<string>;
+export declare function captureNpc(opts: CaptureNpcOptions): Promise<CaptureNpcResult>;
+export type { InspectNpcOptions } from './npc/inspect';
+export type { CaptureNpcOptions, CaptureNpcResult, NpcFrame } from './npc/capture';
+export type { NpcInspection, NpcMetrics, NpcSample, StuckWindow, TargetProgress, Transition } from './npc/metrics';
+export declare function readWorldMetrics(worldDir: string): Promise<import('./world/readWorldMetrics').WorldMetricsTable | null>;
+export declare function renderWorldMetricsText(metrics: import('./world/readWorldMetrics').WorldMetricsTable): Promise<string>;
+export declare const WORLD_METRICS_UNSUPPORTED: string;
+/** The bone axis table, read from a world's OWN pinned system — the engine holds the only authored copy. */
+export declare function readAxisTable(worldDir: string): Promise<{
+    markdown: string;
+    json: unknown;
+} | null>;
 export type PublishResult = {
     slug: string;
     title: string;
@@ -20,8 +117,81 @@ export type PublishResult = {
     buildNumber: number;
     playUrl: string | null;
     worldUrl: string;
+    worldId: string;
+    hasCustomThumbnail: boolean;
+    thumbnailUrl: string | null;
+    thumbnailSource: 'option' | 'bundle' | 'existing' | 'capture' | 'generated';
+    thumbnailWarning: string | null;
+    /** What happened on the opt-in source channel. Always present; `skipped` unless the creator asked. */
+    source: PublishSourceOutcome;
+};
+/**
+ * Outcome of the opt-in source upload (CH-1457 spec §9).
+ *
+ * `failed` rather than a thrown error on purpose: by the time the source
+ * channel runs, the world's build is already published and active. Throwing
+ * would exit `helix publish` non-zero and tell a creator their publish failed
+ * when it did not. The one failure that DOES throw is the archive itself
+ * (too big, missing directory) — that happens before any network call, so
+ * nothing has happened yet and refusing outright is honest.
+ */
+export type PublishSourceOutcome = {
+    state: 'skipped';
+} | {
+    state: 'uploaded';
+    sizeBytes: number;
+    fileCount: number;
+    /** The version id the server recorded — the human-readable handle for this snapshot. */
+    version: string;
+    projectId: string;
+} | {
+    state: 'failed';
+    message: string;
 };
 export type PublishProgress = (message: string) => void;
+export declare const WORLD_DESCRIPTION_MAX = 1000;
+export type PublishWorldOptions = {
+    /** Explicit JSON worldId/placements mapping from normal reservation receipts. */
+    placementBindings?: string;
+    thumbnail?: string;
+    /** Mock-only seam for source tests; public CLI/MCP always use isolated capture. */
+    captureThumbnail?: typeof capturePublishThumbnail;
+    /**
+     * Catalog description. Sent as a separate PATCH because the manifest schema cannot carry it —
+     * `@hypersoniclabs/helix-manifest` is `additionalProperties: false` at every version, so a
+     * `description` key in helix.json is REJECTED by validate. The backend has had the field all
+     * along; nothing was writing it, so every published world's catalog entry showed a title and
+     * nothing else. Declarative support needs a helix-manifest release; this needs neither.
+     */
+    description?: string;
+    /**
+     * Opt-in, OFF BY DEFAULT (CH-1457 spec §9.1). Also upload this project's
+     * source, through a separate private channel, so the world can be opened and
+     * edited on the website later. This flag does not alter the playable Build
+     * upload or its required thumbnail; source remains a separate private channel.
+     */
+    uploadSource?: boolean;
+    /**
+     * Directory the source archive is built from. Defaults to the PARENT of the
+     * bundle directory, because `helix publish [directory]` points at the BUILT
+     * bundle (`dist/`) and the source is not in there.
+     */
+    sourceDir?: string;
+    /**
+     * Skip the pre-publish server-realizability gate. The gate refuses to publish a module-v1 world
+     * whose declared banks the server cannot resolve; skipping it lets you publish a world that will
+     * fail to start for every player. Off by default and deliberately awkward to reach.
+     */
+    skipRealizabilityCheck?: boolean;
+    /** Test/backend-resolver seam; ordinary callers should leave this unset. */
+    realizabilityDeps?: RealizabilityDeps;
+    /**
+     * The REASON this World may ship with an exact engine pin (--allow-exact-engine-pin). Engine systems are
+     * ranges; without this an exact pin is refused before anything touches the network. The override is
+     * appended to ~/.helix/engine-pin-overrides.jsonl (reason, slug, pinned versions) and printed loudly.
+     */
+    allowExactEnginePin?: string;
+};
 type WorldSummary = {
     id: string;
     slug: string;
@@ -29,7 +199,361 @@ type WorldSummary = {
     status: string;
     hasActiveBuild: boolean;
 };
-export declare function publishWorld(root: string, creds: CliCredentials, onProgress?: PublishProgress): Promise<PublishResult>;
+export declare function publishWorld(root: string, creds: CliCredentials, onProgress?: PublishProgress, options?: PublishWorldOptions): Promise<PublishResult>;
+/** Who may stand up a persistent server for a world (backend `ServerCreationPermission`). */
+export declare const SERVER_CREATION_PERMISSIONS: readonly ["creator", "collaborators", "anyone"];
+export type ServerCreationPermission = (typeof SERVER_CREATION_PERMISSIONS)[number];
+/** The slice of HelixApi world creation needs — the seam the specs fake. */
+export type WorldApi = {
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+};
+export type CreateWorldOptions = {
+    title: string;
+    slug: string;
+    description?: string;
+    serverCreationPermission?: ServerCreationPermission;
+};
+/** `created: false` means the slug was already one of yours and nothing was sent. */
+export type CreateWorldResult = {
+    id: string;
+    slug: string;
+    status: string;
+    created: boolean;
+};
+/**
+ * Mint a world ROW without publishing a build — the identity products and
+ * achievements register against.
+ *
+ * Idempotency is CLIENT-side and lookup-first, exactly as publishWorld resolves
+ * a world: the backend 409s a duplicate slug even for its owner (its only
+ * server-side idempotency is keyed on projectId, which the public route's
+ * whitelisting ValidationPipe strips), so a bare re-POST is not an option. A
+ * slug owned by someone else surfaces the backend's 409 verbatim.
+ */
+export declare function createWorld(api: WorldApi, options: CreateWorldOptions): Promise<CreateWorldResult>;
+export type WorldSourceUploadTicket = {
+    key: string;
+    url: string;
+    contentType: string;
+    cacheControl: string;
+    projectId: string;
+    version: string;
+    expiresInSeconds: number;
+};
+export type WorldSourceVersion = {
+    versionId: string;
+    projectId: string;
+    key: string;
+    version: string;
+    sizeBytes: number;
+    createdAt: string;
+};
+/**
+ * Upload one source archive against an already-published world.
+ *
+ * ONE byte length is computed once and sent to BOTH calls. Finalize asserts that
+ * the stored object's size equals the declared size — the presign binds
+ * ContentLength into the signature, so a mismatch means a different object was
+ * finalized than was declared. Reading the length twice from two places is
+ * exactly how that assertion starts failing for no reason.
+ */
+export declare function uploadWorldSource(api: HelixApi, worldId: string, bytes: Buffer): Promise<WorldSourceVersion>;
+/**
+ * One plain sentence for a source-channel failure — never a stack trace.
+ *
+ * The case this exists for: a deployment with no source bucket answers 503 with
+ * a message naming the missing variable. That is operational information, and a
+ * creator should read it as a sentence, not as an `✖ Service Unavailable (503)`
+ * block stapled onto an otherwise successful publish. Pure, so every shape can
+ * be asserted without a server.
+ */
+export declare function describeSourceFailure(err: unknown): string;
+/**
+ * The website host a creator would edit this world on, for the environment the
+ * credentials point at. Production reads `helixgame.com`, which is the string
+ * spec §9.3 writes out; staging and helix3 read their own hosts instead of
+ * pointing a staging creator at production. Same idiom `helix login` uses.
+ */
+export declare function editSiteHost(apiUrl: string): string;
+/**
+ * The single creator-facing line about source, per spec §9.3. A FACT, printed
+ * once — not a warning, not repeated.
+ *
+ * Lives here rather than in the CLI's command layer because MCP renders the
+ * same outcome to an agent and the two must not drift; `howToEnable` is the
+ * only part that differs (a CLI flag vs a tool argument).
+ */
+export declare function sourceOutcomeLine(outcome: PublishSourceOutcome, apiUrl: string, howToEnable?: string): string;
+export type WorldMediaKind = 'thumbnail' | 'preview';
+export type WorldMediaDetail = {
+    id: string;
+    thumbnailUrl: string;
+    hasCustomThumbnail: boolean;
+    previewMediaUrl: string | null;
+};
+export declare function mediaContentTypeFromExtension(file: string): string;
+export declare function findBundleThumbnail(root: string): string | undefined;
+export declare function assertMediaSizeOk(size: number, kind: WorldMediaKind): void;
+export declare function assertMediaSlotWritable(world: WorldMediaDetail, kind: WorldMediaKind, overwrite: boolean): void;
+export declare function setWorldMedia(slug: string, file: string, opts?: {
+    kind?: WorldMediaKind;
+    overwrite?: boolean;
+}): Promise<WorldMediaDetail>;
+export declare function clearWorldMedia(slug: string, kind: WorldMediaKind): Promise<WorldMediaDetail>;
+export { publishGlb, makeItemFromPackage, publishOwnedItemFromPackage, PUBLICATIONS_UPLOAD_PATH, ITEMS_FROM_PACKAGE_PATH } from './publications';
+export type { PublicationReceipt, PublicationOffer, PublishGlbOptions, MakeItemOptions, PublishOwnedItemOptions, MadeItemReceipt } from './publications';
+/** The slice of a delisted item's response this command reads. */
+export type DelistedItem = {
+    id: string;
+    slug: string;
+    title: string;
+    status: string;
+};
+/** The slice of HelixApi `delistItem` needs — the seam the specs fake. */
+export type ItemDelistApi = {
+    requestItem<T>(method: string, path: string, body?: unknown): Promise<T>;
+};
+/**
+ * Delist a published universal item you own (CH-1671). Existing owners keep
+ * what they own; the item stops appearing on browse/marketplace and can no
+ * longer be newly acquired. This does NOT delete anything — `helix item
+ * publish` never made a delete path safe once anyone (including your own
+ * auto-granted copy) owns an instance, and delist is the actual way out.
+ * Only legal from a currently-published item; the server rejects a draft or
+ * an already-delisted one with a clear error (surfaced as ApiError).
+ */
+export declare function delistItem(itemId: string, creds: CliCredentials, opts?: {
+    reason?: string;
+}, deps?: {
+    api?: ItemDelistApi;
+}): Promise<DelistedItem>;
+export declare const achievementsWorldPath: (worldId: string) => string;
+/** The subset of the backend's AchievementResponse these commands read. */
+export type Achievement = {
+    id: string;
+    itemId: string;
+    worldId: string | null;
+    key: string;
+    name: string;
+    description: string | null;
+    hidden: boolean;
+    points: number;
+    active: boolean;
+    unlockMode: string;
+    criteria: AchievementCriteria | null;
+    iconUrl: string | null;
+    meshUrl: string | null;
+    hasCustomTrophy: boolean;
+    earnedCount: number;
+    earnPct: number | null;
+    rarityTier: string;
+    unranked: boolean;
+    createdAt: string;
+};
+export type AchievementFilePart = {
+    file: string;
+    contentType: string;
+    sizeBytes: number;
+};
+export type AchievementRegistrationPlan = {
+    worldSlug: string;
+    fields: AchievementRegistrationFields;
+    icon: AchievementFilePart;
+    trophy: AchievementFilePart | null;
+    warnings: string[];
+    iconBytes: Buffer;
+    trophyBytes: Buffer | null;
+};
+export type RegisterAchievementOptions = AchievementRegistrationInput & {
+    worldSlug: string;
+    /** The 2D badge graphic. REQUIRED — the backend refuses an achievement without one. */
+    icon: string;
+    /** Optional bespoke GLB trophy; omitted, the backend bakes the icon onto the default plaque. */
+    trophy?: string;
+};
+/**
+ * Everything `--dry-run` checks: the field rules, both files read and sniffed,
+ * and the icon proven to be a real, non-blank graphic. No network and no login,
+ * so an agent can verify a registration before asking a human to sign in.
+ */
+export declare function planAchievementRegistration(opts: RegisterAchievementOptions): Promise<AchievementRegistrationPlan>;
+/** The slice of HelixApi the achievement flows need — the seam the specs fake. */
+export type AchievementApi = {
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    requestItem<T>(method: string, path: string, body?: unknown): Promise<T>;
+    sendMultipart<T>(method: string, path: string, form: FormData): Promise<T>;
+};
+/**
+ * Register (and mint the soulbound item for) a world achievement. Validate
+ * locally → resolve the slug → one multipart POST. Throws ApiError
+ * (render()-able) on any server rejection — a duplicate key included.
+ */
+export declare function registerAchievement(opts: RegisterAchievementOptions, creds: CliCredentials, deps?: {
+    api?: AchievementApi;
+    onProgress?: PublishProgress;
+}): Promise<{
+    achievement: Achievement;
+    warnings: string[];
+}>;
+/** Every achievement registered to a world, newest rollup data included. */
+export declare function listAchievements(worldSlug: string, creds: CliCredentials, deps?: {
+    api?: AchievementApi;
+}): Promise<Achievement[]>;
+/**
+ * Patch a registered achievement. `key`, `unlockMode` and `criteria` are NOT
+ * patchable by design — a key is the identifier rules name, and re-declaring
+ * how a badge is earned would silently re-label every copy already granted.
+ */
+export declare function updateAchievement(worldSlug: string, key: string, patch: AchievementUpdateInput, creds: CliCredentials, deps?: {
+    api?: AchievementApi;
+}): Promise<Achievement>;
+/**
+ * Replace the 2D graphic. This endpoint exists because creators were driving the
+ * generic universal-items presign route instead, which SUSPENDS the achievement;
+ * it also re-bakes the default plaque, so the change reaches the 3D badge too.
+ */
+export declare function setAchievementIcon(worldSlug: string, key: string, file: string, creds: CliCredentials, deps?: {
+    api?: AchievementApi;
+}): Promise<Achievement>;
+export declare const ITEM_DISTRIBUTIONS_PATH = "/api/v1/item-distributions";
+export declare const ITEM_DISTRIBUTIONS_CREATOR_PATH = "/api/v1/item-distributions/creator";
+export type ItemDistribution = {
+    id: string;
+    itemId: string;
+    issuerId: string;
+    channel: 'marketplace' | 'world';
+    worldId: string | null;
+    worldSlug?: string | null;
+    key: string | null;
+    priceLix: number;
+    isFree: boolean;
+    active: boolean;
+    maxPerPlayer: number | null;
+    maxClaims: number | null;
+    startsAt: string | null;
+    endsAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+/** A route is a Claim (free) when the server says so or its price is 0; the price may arrive as a number or a decimal
+ *  string, so `=== 0` alone mislabels a free route "Buy". */
+export declare function isClaimRoute(d: {
+    priceLix?: unknown;
+    isFree?: unknown;
+}): boolean;
+/** First line of `helix item distribution create`. `requestedPriceLix` backs up a response that omits the price. */
+export declare function distributionCreatedHeadline(created: {
+    priceLix?: unknown;
+    isFree?: unknown;
+}, requestedPriceLix?: number): string;
+export type DistributionApi = {
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+};
+export type CreateItemDistributionOptions = Omit<ItemDistributionInput, 'worldId'> & {
+    itemId: string;
+};
+/** Resolve an optional creator world slug, then create one canonical route. */
+export declare function createItemDistribution(options: CreateItemDistributionOptions, creds: CliCredentials, deps?: {
+    api?: DistributionApi;
+    onProgress?: PublishProgress;
+}): Promise<ItemDistribution>;
+export declare function listItemDistributions(itemId: string, creds: CliCredentials, deps?: {
+    api?: DistributionApi;
+}): Promise<ItemDistribution[]>;
+export declare function updateItemDistribution(distributionId: string, input: ItemDistributionUpdateInput, creds: CliCredentials, deps?: {
+    api?: DistributionApi;
+}): Promise<ItemDistribution>;
+export declare function disableItemDistribution(distributionId: string, creds: CliCredentials, deps?: {
+    api?: DistributionApi;
+}): Promise<ItemDistribution>;
+export declare const PRODUCTS_PATH = "/api/v1/iwp/products";
+export declare const CREATOR_WORLDS_PATH = "/api/v1/iwp/creator/worlds";
+export declare const productsWorldPath: (worldId: string) => string;
+/** The backend's product DTO (`toProductDtoShape`) — `name` is an alias of `title`. */
+export type WorldProduct = {
+    id: string;
+    key: string | null;
+    worldId: string;
+    worldSlug: string | null;
+    worldTitle: string | null;
+    worldDetailPath: string | null;
+    name: string;
+    title: string;
+    description: string | null;
+    priceLix: number;
+    isFree: boolean;
+    type: string;
+    itemId: string | null;
+    /** The authored effect list; null on a legacy product, whose effects derive from type/itemId. */
+    grants: ProductGrant[] | null;
+    maxPerUser: number | null;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+/** A Published world plus its registry — what the creator-worlds route returns. */
+export type ProductWorld = {
+    id: string;
+    slug: string;
+    title: string;
+    description: string | null;
+    status: string;
+    detailPath: string | null;
+    products: WorldProduct[];
+};
+export type RegisterProductOptions = ProductRegistrationInput & {
+    worldSlug: string;
+};
+export type ProductRegistrationPlan = {
+    worldSlug: string;
+    fields: ProductRegistrationFields;
+    warnings: string[];
+};
+/**
+ * Everything `--dry-run` checks: the field rules and the type/item coherence.
+ * No network and no login, so an agent can verify a registration before asking
+ * a human to sign in.
+ */
+export declare function planProductRegistration(opts: RegisterProductOptions): ProductRegistrationPlan;
+/** The slice of HelixApi the product flows need — the seam the specs fake. */
+export type ProductApi = {
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+};
+/**
+ * Register a purchasable product on a world: validate locally → resolve the slug
+ * → one JSON POST. Throws ApiError (render()-able) on any server rejection — a
+ * duplicate key, an unpublished linked item, or a non-owned world included.
+ */
+export declare function registerProduct(opts: RegisterProductOptions, creds: CliCredentials, deps?: {
+    api?: ProductApi;
+    onProgress?: PublishProgress;
+}): Promise<{
+    product: WorldProduct;
+    warnings: string[];
+}>;
+/** Every product registered to a world, active or not. */
+export declare function listProducts(worldSlug: string, creds: CliCredentials, deps?: {
+    api?: ProductApi;
+}): Promise<WorldProduct[]>;
+/** Every PUBLISHED world of the caller's with its registry — the "where can I sell?" view. */
+export declare function listProductWorlds(creds: CliCredentials, deps?: {
+    api?: ProductApi;
+}): Promise<ProductWorld[]>;
+/**
+ * Patch a registered product. `key` and `type` are NOT patchable by design — a
+ * key is what world code buys (`pkey:<key>`), and changing what a purchase
+ * hands over would re-label every copy already sold.
+ */
+export declare function updateProduct(worldSlug: string, ref: string, patch: ProductUpdateInput, creds: CliCredentials, deps?: {
+    api?: ProductApi;
+}): Promise<WorldProduct>;
+/**
+ * Take a product off sale (or put it back). Deactivating is the only way to
+ * retire one: the row stays, so past purchases and their grants still resolve.
+ */
+export declare function setProductActive(worldSlug: string, ref: string, active: boolean, creds: CliCredentials, deps?: {
+    api?: ProductApi;
+}): Promise<WorldProduct>;
 export type PublishPackageResult = {
     kind: string;
     slug: string;
@@ -37,8 +561,36 @@ export type PublishPackageResult = {
     revision: number;
     codeBaseUrl: string;
     assetBaseUrl: string | null;
+    checksumSha256: string | null;
+};
+export type PackagePublishApi = Pick<HelixApi, 'request' | 'requestItem'>;
+export type PublishPackageDeps = {
+    api?: PackagePublishApi;
+    validator?: Awaited<ReturnType<typeof loadVendoredValidator>>;
+    upload?: typeof uploadToTicket;
+};
+export declare function publishPackage(root: string, creds: CliCredentials, onProgress?: PublishProgress, deps?: PublishPackageDeps): Promise<PublishPackageResult>;
+export type PublishInteractableResult = PublishPackageResult & {
+    item: {
+        id: string;
+        slug: string;
+        title: string;
+    };
+    distribution: {
+        id: string;
+        priceLix: string;
+        active: boolean;
+    };
+    bundle: {
+        kind: 'interactable-bundle';
+        id: string;
+        version: string;
+        checksumSha256: string;
+    };
 };
-export declare function publishPackage(root: string, creds: CliCredentials, onProgress?: PublishProgress): Promise<PublishPackageResult>;
+export declare function publishInteractable(root: string, creds: CliCredentials, onProgress?: PublishProgress, deps?: PublishPackageDeps & {
+    publishPackage?: typeof publishPackage;
+}): Promise<PublishInteractableResult>;
 export type CatalogPackage = {
     kind: string;
     slug: string;
@@ -114,3 +666,15 @@ export declare function checkForUpdates(opts?: {
     installed?: Record<string, string>;
     scope?: string;
 }): Promise<ToolchainStatus[]>;
+export { runUnrealDoctor, locateEditorCmd, findUProject, DOCTOR_REPORT_SCHEMA, type UnrealDoctorReport, type UnrealDoctorResult, type UnrealDoctorFinding, type UnrealDoctorVerdict, type UnrealEditorInvocation, } from './unreal/doctor';
+export { refreshItemThumbnail, setItemThumbnail, describeThumbnailError, renderItemThumbnailResult, MAX_ITEM_THUMBNAIL_BYTES, type ItemThumbnailRefreshOptions, type ItemThumbnailRefreshResult, type ItemThumbnailSetResult, type ItemThumbnailSourceLane, } from './itemThumbnail';
+export { bakeFoliageLods, type BakeFoliageLodsOptions } from './placements/foliageLods';
+export { attachFoliageLods } from './placements/attachFoliageLods';
+export { bakeSceneHlod, inspectSceneHlod, tagSceneHlod, planSceneHlod, DEFAULT_HLOD_LAYER, HLOD_BAKER_VERSION, type HlodBakeReceipt, type SceneHlodBakeOptions } from './sceneHlod/scene';
+export { bakeHlodSurface } from './sceneHlod/bakeSurface';
+export { approximateHlodGeometry, type HlodApproximationMetrics } from './sceneHlod/approximate';
+export { planSharedHlodAtlas, bakeSharedHlodAtlas, type HlodSharedAtlasPlan, type HlodSharedAtlas } from './sceneHlod/sharedAtlas';
+export { writeHlodCellGlb, writeSharedHlodMaterialGlb, type HlodCellGeometry } from './sceneHlod/cellArtifact';
+export { bakeCompleteSceneHlod, DEFAULT_COMPLETE_HLOD_SETTINGS, type CompleteSceneHlodOptions } from './sceneHlod/complete';
+export { bakeSceneHlodRefinements, DEFAULT_HLOD_REFINEMENT_SETTINGS, type SceneHlodRefinementOptions } from './sceneHlod/refinement';
+export type { HlodSurface, HlodMaterial, HlodImage, HlodBakeOptions, HlodBakeResult, HlodBakeMetrics } from './sceneHlod/types';