@rightkit/social-ui 0.0.0-stage → 0.1.0

package/dist/data/engine/engineDataSource.d.ts

@@ -0,0 +1,194 @@
+import type { DataSource, Result, UnmappedAccount as UnmappedAccountView } from "../source.js";
+import type { Account, AccountDisconnect, Campaign, CampaignAttribution, ChannelLink, DateRange, Digest, FailureItem, FailureResolution, ModerationCapability, PublishJob, PublishJobRecord, ManualDraft, OperatorScope, OptimiseProposal, ReconcileResult, RejectDecision, SpendAllowance, SpendPrice, SpendReport, ThreadItem, TrackedLink, HookTestSet, ContentDetail, ContentExperimentSummary, ContentRecord, DigestApplication, ResearchDigest, DeliveryEnvelope, DispatchAttempt, GateCheck, GatePolicy, GateRecord, OutgoingBrief, OutgoingBriefDetail, ChannelMemoryDetail, ChannelMemoryRevision, ProofRecord, ProofStatus, TypedBrief, BriefVariant, AnalyticsObservation, AnalyticsPost, MetricImport, HeartbeatStatus, RestoreReceiptList, InboxListing, InboxRaw, InboxStats, PublishNextView, PublishQuota } from "../types.js";
+export declare class EngineDataSource implements DataSource {
+    readonly kind: "daemon";
+    /** Accounts from the last listAccounts that the desktop could not map. */
+    private unmapped;
+    /**
+     * The browser clock. The engine has no clock method yet, so countdowns use this value and not the
+     * daemon's clock. See "Engine gaps" in the design doc.
+     */
+    nowUtc(): string;
+    /**
+     * Every stored account, from account.list, mapped to the operator's Account. Fields the engine
+     * does not hold take the named fallbacks in mapping.ts ("Accounts"). Each account maps on its own:
+     * one whose platform or state the desktop does not show yet is left out of the result and kept,
+     * with its typed error, in unmappedAccounts(). The other accounts still load. A failed call throws.
+     */
+    listAccounts(): Promise<Account[]>;
+    /** The accounts the last listAccounts could not map, each with the reason the desktop gives. */
+    unmappedAccounts(): readonly UnmappedAccountView[];
+    /**
+     * Every calendar entry in the range. Each entry carries its publish progress (permalink, waiting
+     * time, failure) from the engine's publish job for that entry revision. Publish reads run in every
+     * role, so the desktop sees the daemon's progress.
+     */
+    listJobs(range: DateRange): Promise<PublishJob[]>;
+    /** Null when the id is unknown to the engine for its scope (not_found). */
+    getJob(jobId: string): Promise<PublishJob | null>;
+    /**
+     * Failure rows from publish jobs in state failed, outcome_unknown, or cancelled with a reason, from
+     * publish.list per scope. A failed read throws (the screen's load error), so an empty list always
+     * means no failures. The failures do not depend on the digest, which still has no engine source.
+     */
+    listFailures(): Promise<FailureItem[]>;
+    /**
+     * Every publish job in one scope, from publish.list, newest first. A read of the stored job only: the desktop
+     * never steps, runs, reconciles, cancels or resolves a job. A failed read throws; an empty list is a state.
+     */
+    listPublishJobs(scopeId: string): Promise<PublishJobRecord[]>;
+    listDigest(): Promise<Digest>;
+    listThreads(): Promise<ThreadItem[]>;
+    listModerationCapabilities(): Promise<ModerationCapability[]>;
+    /**
+     * Approves exactly `revision`. The account is checked here first, as the daemon does; the engine
+     * then checks the revision itself. The engine approves without checking media readiness, so the
+     * screen's own gate is the only media check (see "Engine gaps").
+     */
+    approve(jobId: string, revision: number, expectedAccountId: string): Promise<Result<PublishJob>>;
+    reject(jobId: string, decision: RejectDecision): Promise<Result<PublishJob>>;
+    /**
+     * Pauses one account. The engine's pause needs the revision the operator saw; the desktop reads the
+     * current revision first, so the write is a compare-and-swap against that read. A revision that
+     * moved in between is revision_conflict and nothing is paused.
+     */
+    pauseAccount(id: string, reason: string): Promise<Result<Account>>;
+    /** Resumes one account, with the same revision read and compare-and-swap as pauseAccount. */
+    resumeAccount(id: string): Promise<Result<Account>>;
+    /**
+     * Disconnects one account with account.disconnect: the connection ends and the account's queued and waiting
+     * publish jobs are cancelled in one engine transaction. Same revision read and compare-and-swap as pauseAccount.
+     */
+    disconnectAccount(id: string): Promise<Result<AccountDisconnect>>;
+    /**
+     * The platform check is publish.reconcile, which is refused in the desktop role. It never reaches
+     * the engine from here, so the desktop makes no platform call.
+     */
+    reconcile(_jobId: string): Promise<Result<ReconcileResult>>;
+    /**
+     * Publish failures are resolved on the daemon (publish.reconcile and publish.cancel are role-gated).
+     * Other failure kinds have no engine method yet.
+     */
+    resolveFailure(failureId: string, _resolution: FailureResolution, _note: string): Promise<Result<FailureItem>>;
+    resolveThread(_threadId: string): Promise<Result<ThreadItem>>;
+    snoozeThread(_threadId: string, _untilUtc: string): Promise<Result<ThreadItem>>;
+    /** Every draft in every stored channel, from draft.list per scope, newest update first. */
+    listDrafts(): Promise<ManualDraft[]>;
+    /** Approves exactly `revision` when the engine's gate passes. The disclosure phrases come from the caller. */
+    approveDraft(draftId: string, revision: number, disclosurePhrases: readonly string[]): Promise<Result<ManualDraft>>;
+    /** Records the operator's post. The engine checks the link: https, on an allowed host for the platform. */
+    markDraftPosted(draftId: string, revision: number, postedUrl: string): Promise<Result<ManualDraft>>;
+    /** Ends a drafted or approved draft with a reason. The engine refuses a blank reason. */
+    skipDraft(draftId: string, revision: number, reason: string): Promise<Result<ManualDraft>>;
+    /** Every stored channel, from channel.list, labelled as venture / channel / account. */
+    listScopes(): Promise<OperatorScope[]>;
+    /** Every suggestion in one scope, from optimise.list, in the engine's creation order. */
+    listProposals(scopeId: string): Promise<OptimiseProposal[]>;
+    /** One suggestion with its lineage, from optimise.get. Null when the engine does not hold it in this scope. */
+    getProposal(scopeId: string, proposalId: string): Promise<OptimiseProposal | null>;
+    /** Accepts at exactly `expectedRevision`. The engine creates the draft entry; nothing is approved here. */
+    acceptProposal(scopeId: string, proposalId: string, expectedRevision: number): Promise<Result<OptimiseProposal>>;
+    /** Dismisses at exactly `expectedRevision`. The engine writes only the suggestion row. */
+    dismissProposal(scopeId: string, proposalId: string, expectedRevision: number): Promise<Result<OptimiseProposal>>;
+    /** The month's allowance, from allowance.get. The engine's not_found is "no allowance set", so it returns null. */
+    getAllowance(scopeId: string, month: string): Promise<SpendAllowance | null>;
+    /** The month report, from spend.report. The engine's allowance_missing is "no allowance set", so it returns null. */
+    spendReport(scopeId: string, month: string): Promise<SpendReport | null>;
+    /** The latest version of every price route, from price.list, with qualification at the browser clock. */
+    listPrices(): Promise<SpendPrice[]>;
+    /** Every campaign in one scope, from campaign.list. */
+    listCampaigns(scopeId: string): Promise<Campaign[]>;
+    /** The tracked links of one campaign, from link.list filtered by campaign id. */
+    listCampaignLinks(scopeId: string, campaignId: string): Promise<TrackedLink[]>;
+    /** The visit counts of one campaign, from link.attribution. Null when the engine holds no such campaign in the scope. */
+    campaignAttribution(scopeId: string, campaignId: string): Promise<CampaignAttribution | null>;
+    /**
+     * Every tracked link in one scope. campaign.list gives the campaigns; for each one, link.list and link.attribution
+     * are read together. Both are read-only, and any failed read throws, so the screen shows its load error.
+     */
+    listChannelLinks(scopeId: string): Promise<ChannelLink[]>;
+    /** Every hook test set in one scope, from hook_test.list. Reading the sets here decides nothing. */
+    listHookTests(scopeId: string): Promise<HookTestSet[]>;
+    /** One hook test set with its openings, from hook_test.get. Null when no set with this id is in the scope. */
+    getHookTest(scopeId: string, setId: string): Promise<HookTestSet | null>;
+    /** Every digest in one scope, from digest.list. */
+    listDigests(scopeId: string): Promise<ResearchDigest[]>;
+    /** One digest with its entries, from digest.get. Null when no digest with this id is in the scope. */
+    getDigest(scopeId: string, digestId: string): Promise<ResearchDigest | null>;
+    /** Which digest entries became draft calendar entries, from digest.applied. Null when the digest is not in the scope. */
+    digestApplications(scopeId: string, digestId: string): Promise<DigestApplication[] | null>;
+    /** Every content record in one scope, from content.list, read at the browser clock so expiry is derived. */
+    listContent(scopeId: string): Promise<ContentRecord[]>;
+    /** One record with its variants, from content.get. Null when no record with this id is in the scope. */
+    getContent(scopeId: string, contentId: string): Promise<ContentDetail | null>;
+    /** The variant comparison for one record, from content.experiment_summary. Null when the record is not in the scope. */
+    contentExperimentSummary(scopeId: string, contentId: string): Promise<ContentExperimentSummary | null>;
+    /** The latest gate policy, from gate_policy.get. Null when the engine answers policy_missing: nothing can pass. */
+    gatePolicy(scopeId: string): Promise<GatePolicy | null>;
+    /**
+     * A dry-run check of one script, from gate.check. Nothing is stored. A refusal (hidden characters, no
+     * policy) comes back as a Result with the engine's code, so the screen shows it as a notice.
+     */
+    checkText(scopeId: string, subjectId: string, text: string): Promise<Result<GateCheck>>;
+    /** The stored verdict records of one subject, newest first, from gate.records. */
+    gateRecords(scopeId: string, subjectId: string): Promise<GateRecord[]>;
+    /** Every outgoing brief in one scope, from brief_out.list. */
+    listBriefs(scopeId: string): Promise<OutgoingBrief[]>;
+    /** One brief with its summary and document, from brief_out.get. Null when no brief has this request id in the scope. */
+    getBrief(scopeId: string, requestId: string): Promise<OutgoingBriefDetail | null>;
+    /** Every accepted delivery in one scope, from delivery.list. */
+    listDeliveries(scopeId: string): Promise<DeliveryEnvelope[]>;
+    /** One delivery envelope, from delivery.get. Null when no envelope has this id in the scope. */
+    getDelivery(scopeId: string, envelopeId: string): Promise<DeliveryEnvelope | null>;
+    /** The dispatch attempts of one brief, from dispatch.list filtered by request id, oldest first. */
+    listDispatchAttempts(scopeId: string, requestId: string): Promise<DispatchAttempt[]>;
+    /** The latest memory revision with its document, from memory.get. Null when the engine answers not_found: nothing written yet. */
+    channelMemory(scopeId: string): Promise<ChannelMemoryDetail | null>;
+    /** Every stored memory revision, newest first, from memory.history. An empty list when nothing is stored. */
+    channelMemoryHistory(scopeId: string): Promise<ChannelMemoryRevision[]>;
+    /** The proofs of one scope, from proof.list. A null status sends no status filter, so every status is listed. */
+    listProofs(scopeId: string, status: ProofStatus | null): Promise<ProofRecord[]>;
+    /** Every typed brief in one scope, from typed_brief.list, ordered by brief id. */
+    listTypedBriefs(scopeId: string): Promise<TypedBrief[]>;
+    /** One brief, from typed_brief.get. Null when the engine answers not_found: no brief with this id in the scope. */
+    getTypedBrief(scopeId: string, briefId: string): Promise<TypedBrief | null>;
+    /** The variants of one brief, from variant.list, ordered by platform then variant id. */
+    listBriefVariants(scopeId: string, briefId: string): Promise<BriefVariant[]>;
+    /** Every published post in one scope with its latest metrics, from analytics.summary. */
+    listAnalyticsPosts(scopeId: string): Promise<AnalyticsPost[]>;
+    /** The stored observations of one post, from analytics.list filtered to its job. The engine orders them oldest first. */
+    listAnalyticsObservations(scopeId: string, jobId: string): Promise<AnalyticsObservation[]>;
+    /** Every committed manual import in one scope, from metric_import.list. */
+    listMetricImports(scopeId: string): Promise<MetricImport[]>;
+    /** The heartbeat record's state at `nowUtc`, from heartbeat.status. Ages and states are the engine's. */
+    heartbeatStatus(nowUtc: string, staleAfterSecs: number): Promise<HeartbeatStatus>;
+    /** Every restore receipt, newest first, from store.restore_receipts. */
+    listRestoreReceipts(): Promise<RestoreReceiptList>;
+    /** The newest page of events of one channel account, or of the unmatched events when scopeId is null. */
+    listInbox(scopeId: string | null): Promise<InboxListing>;
+    /** The raw item of one event. Null when the engine holds no event with this id in the scope (not_found). */
+    getInboxEvent(scopeId: string | null, eventId: string): Promise<InboxRaw | null>;
+    /** Event and delivery counts from inbox.stats. The engine takes no input and keeps no per-channel refusal count. */
+    inboxStats(): Promise<InboxStats>;
+    /** publish.next for every account of one channel, decided at the browser clock. Every row is kept. */
+    listPublishNext(scopeId: string): Promise<PublishNextView>;
+    /** publish.quota_get for one account, read at the browser clock. A failed read throws; the screen shows it for that account. */
+    getPublishQuota(scopeId: string, platform: string, remoteAccount: string): Promise<PublishQuota>;
+    /** An accept or dismiss: the engine's reply as a Result. Revision and state errors come back as typed codes. */
+    private decideProposal;
+    /** Every stored channel's scope, from channel.list. Scope is the only key the engine has. */
+    private scopes;
+    /**
+     * The publish jobs in one scope, from publish.list. Reads run in every engine role. Any engine error
+     * throws, so the screen shows its load error rather than an empty list.
+     */
+    private publishJobsFor;
+    /** An account write's reply: the stored account as an Account, or the mapped engine error. */
+    private accountResult;
+    /** A draft write's reply: the stored draft as a ManualDraft, or the mapped engine error. */
+    private draftResult;
+    /** A calendar write's reply: the stored entry as a job, or the mapped engine error. */
+    private entryResult;
+    /** The mapped error for a failed call. A revision conflict reads the current revision from the engine. */
+    private failure;
+}