@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/integrations/fake/inbound-translator.js

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+import { PullRequestCheckState, PullRequestState, ReviewActorKind, ReviewerAuthorizationSource, } from '../../activities/index.js';
+import { correlationId, EventActorKind } from '../../kernel/index.js';
+import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, resourceId, } from '../../resources/index.js';
+import { workItemId } from '../../work/index.js';
+import { admitObservedWork } from '../application/work-admission.js';
+import { FakeEventType } from './external-source.js';
+const evidenceSchema = z
+    .object({
+    key: z.string().min(1),
+    title: z.string().min(1),
+    tags: z.array(z.string().trim().min(1)).readonly().optional(),
+    kind: z.enum(['issue', 'pull-request']).optional(),
+    revision: z.string().min(1).optional(),
+    branch: z.string().min(1).optional(),
+    baseRevision: z.string().min(1).optional(),
+    checks: z.enum(['unknown', 'pending', 'passing', 'failing']).optional(),
+    acceptedReview: z.boolean().optional(),
+    reviewActorId: z.string().min(1).optional(),
+    reviewActorKind: z.enum(['human', 'bot']).optional(),
+    reviewerId: z.string().min(1).optional(),
+    changedFiles: z.array(z.string().min(1)).readonly().optional(),
+    watchEvent: z.literal(FakeEventType.ReviewRequested).optional(),
+    eligible: z.boolean().optional(),
+})
+    .strict();
+export class FakeInboundTranslator {
+    adapter;
+    services;
+    constructor(adapter, services) {
+        this.adapter = adapter;
+        this.services = services;
+    }
+    async runOnce(limit = 100) {
+        const checkpoint = `reactor:integration.${this.adapter}.inbound`;
+        const events = await this.services.journal.readAll(await this.services.checkpoints.load(checkpoint), limit);
+        for (const event of events) {
+            if (event.eventType === FakeEventType.WorkObserved && event.stream.id === this.adapter)
+                await this.apply(evidenceSchema.parse(event.payload), event);
+            await this.services.checkpoints.save(checkpoint, event.globalPosition);
+        }
+        return events.length;
+    }
+    async apply(evidence, event) {
+        if (evidence.eligible === false)
+            return;
+        const isPullRequest = evidence.kind === 'pull-request';
+        const externalKey = { adapter: this.adapter, key: evidence.key };
+        const context = {
+            commandId: `${event.eventId}:inbound`,
+            correlationId: correlationId(event.correlationId),
+            occurredAt: event.occurredAt,
+            actor: { kind: EventActorKind.Integration, id: this.adapter },
+        };
+        if (await this.updateExisting(externalKey, isPullRequest, evidence, event, context))
+            return;
+        const resource = resourceId(this.services.ids.next('resource'));
+        const work = workItemId(this.services.ids.next('work'));
+        await admitObservedWork(this.services, {
+            adapter: this.adapter,
+            resourceId: resource,
+            workItemId: work,
+            kind: isPullRequest ? BuiltInResourceKind.PullRequest : BuiltInResourceKind.Issue,
+            externalKey,
+            capabilities: isPullRequest
+                ? [
+                    BuiltInResourceCapability.Commentable,
+                    BuiltInResourceCapability.Reviewable,
+                    BuiltInResourceCapability.Approvable,
+                    BuiltInResourceCapability.Mergeable,
+                    BuiltInResourceCapability.Revisioned,
+                    ...(evidence.changedFiles === undefined
+                        ? []
+                        : [BuiltInResourceCapability.ChangedFiles]),
+                ]
+                : [BuiltInResourceCapability.Commentable],
+            objective: evidence.title,
+            tags: evidence.tags ?? [],
+            ...(evidence.revision === undefined ? {} : { revision: evidence.revision }),
+        }, context, isPullRequest
+            ? async () => {
+                await this.observePullRequest(resource, work, evidence, event, context);
+            }
+            : undefined);
+    }
+    async updateExisting(externalKey, isPullRequest, evidence, event, context) {
+        const existing = await this.services.resources.findByExternalKey(externalKey);
+        if (existing === null)
+            return false;
+        const correlation = (await this.services.resources.correlations(existing.resourceId)).find((candidate) => candidate.role === ResourceCorrelationRole.Primary);
+        if (correlation === undefined)
+            throw new Error(`Resource ${existing.resourceId} lacks a primary work correlation`);
+        if (existing.revision !== evidence.revision)
+            await this.services.resources.discover({
+                resourceId: existing.resourceId,
+                kind: existing.kind,
+                externalKey,
+                capabilities: existing.capabilities,
+                ...(evidence.revision === undefined ? {} : { revision: evidence.revision }),
+            }, context);
+        if (isPullRequest)
+            await this.observePullRequest(existing.resourceId, correlation.workItemId, evidence, event, context);
+        return true;
+    }
+    async observePullRequest(resourceId, workItemId, evidence, event, context) {
+        const revision = evidence.revision ?? 'unknown';
+        await this.services.pullRequests.observe({
+            resourceId,
+            workItemId,
+            state: PullRequestState.Open,
+            headRevision: revision,
+            baseRevision: evidence.baseRevision ?? 'unknown',
+            checks: evidence.checks ?? PullRequestCheckState.Unknown,
+            ...(evidence.changedFiles === undefined ? {} : { changedFiles: evidence.changedFiles }),
+        }, context);
+        if (evidence.acceptedReview === true)
+            await this.services.pullRequests.acceptReviewSignal({
+                resourceId,
+                revision,
+                actorId: evidence.reviewActorId ?? 'fake-reviewer',
+                actorKind: evidence.reviewActorKind === 'bot' ? ReviewActorKind.Bot : ReviewActorKind.Human,
+                acceptedEventId: `${event.eventId}:accepted-review`,
+                resourceAuthorId: 'fake-author',
+                authorization: {
+                    source: ReviewerAuthorizationSource.ConfiguredReviewer,
+                    reviewerId: evidence.reviewerId ?? evidence.reviewActorId ?? 'fake-reviewer',
+                },
+            }, context);
+    }
+}

package/dist/src/integrations/fake/provider.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { PullRequestCheckState, ReviewActorKind } from '../../activities/index.js';
+import { BuiltInResourceCapability } from '../../resources/index.js';
+import { ArtifactVerificationResult } from '../contracts/artifact-vocabulary.js';
+import { DurableFakeDeliveryProvider } from './durable-delivery-provider.js';
+import { FakeEventType, FakeExternalEventSource } from './external-source.js';
+import { FakeInboundTranslator } from './inbound-translator.js';
+const configSchema = z
+    .object({
+    enabled: z.boolean(),
+    events: z
+        .array(z
+        .object({
+        key: z.string().min(1),
+        title: z.string().min(1),
+        kind: z.enum(['issue', 'pull-request']).optional(),
+        revision: z.string().min(1).optional(),
+        branch: z.string().min(1).optional(),
+        baseRevision: z.string().min(1).optional(),
+        checks: z
+            .enum([
+            PullRequestCheckState.Unknown,
+            PullRequestCheckState.Pending,
+            PullRequestCheckState.Passing,
+            PullRequestCheckState.Failing,
+        ])
+            .optional(),
+        acceptedReview: z.boolean().optional(),
+        reviewActorId: z.string().min(1).optional(),
+        reviewActorKind: z.enum([ReviewActorKind.Human, ReviewActorKind.Bot]).optional(),
+        reviewerId: z.string().min(1).optional(),
+        changedFiles: z.array(z.string().min(1)).optional(),
+        watchEvent: z.literal(FakeEventType.ReviewRequested).optional(),
+        eligible: z.boolean().optional(),
+    })
+        .strict())
+        .default([]),
+    deliveryEffects: z.record(z.string(), z.string()).default({}),
+    effectsFile: z.string().min(1).optional(),
+    // Deterministic test hook: when set, checkConnectivity rejects with this
+    // message instead of resolving, so doctor's failure path is exercisable
+    // without a real network dependency.
+    connectivityError: z.string().min(1).optional(),
+    // Deterministic test hook: when set, create() throws this message instead
+    // of constructing the provider, so composition's provider-construction
+    // failure tolerance (e.g. missing sandbox auth) is exercisable without a
+    // real credential dependency.
+    createError: z.string().min(1).optional(),
+})
+    .passthrough();
+export const fakeProviderDefinition = {
+    provider: 'fake',
+    eventTypes: [],
+    parseConfig(value) {
+        return configSchema.parse(value);
+    },
+    create({ adapter, config, services }) {
+        if (config.createError !== undefined)
+            throw new Error(config.createError);
+        if (services === undefined)
+            throw new Error('Fake provider requires composed services');
+        return {
+            adapter,
+            eventTypes: [FakeEventType.WorkObserved, FakeEventType.ReviewRequested],
+            source: new FakeExternalEventSource(adapter, config.events),
+            delivery: new DurableFakeDeliveryProvider({
+                effects: config.deliveryEffects,
+                ...(config.effectsFile === undefined ? {} : { effectsFile: config.effectsFile }),
+            }),
+            verifyArtifact: async (kind, externalKey, context) => {
+                const evidence = config.events.find((event) => event.key === externalKey.key);
+                if (evidence === undefined || (evidence.kind ?? 'issue') !== 'pull-request')
+                    return ArtifactVerificationResult.NotFound;
+                if (kind !== 'pull-request' || evidence.branch !== context.workspaceBranch)
+                    return ArtifactVerificationResult.NotFound;
+                return {
+                    kind,
+                    externalKey,
+                    capabilities: [
+                        BuiltInResourceCapability.Reviewable,
+                        BuiltInResourceCapability.Approvable,
+                        BuiltInResourceCapability.Mergeable,
+                        BuiltInResourceCapability.Revisioned,
+                    ],
+                    ...(evidence.revision === undefined ? {} : { revision: evidence.revision }),
+                };
+            },
+            inbound: new FakeInboundTranslator(adapter, services),
+            checkConnectivity: async () => {
+                if (config.connectivityError !== undefined)
+                    throw new Error(config.connectivityError);
+            },
+        };
+    },
+};

package/dist/src/integrations/github/application/agent-context-reader.js

@@ -0,0 +1,54 @@
+import { ResourceCorrelationRole } from '../../../resources/index.js';
+import { adapterId } from '../../contracts/identifiers.js';
+import { integrationStream } from '../../contracts/streams.js';
+import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
+import { createCommentHistoryReader } from './comment-history-reader.js';
+export function createGitHubAgentContextReader(journal, resources) {
+    const commentHistory = createCommentHistoryReader(journal, resources);
+    return {
+        async forWorkItem(workItemId) {
+            const comments = await commentHistory.forWorkItem(workItemId);
+            return {
+                ...(await currentWorkItemContent(journal, resources, workItemId)),
+                comments,
+            };
+        },
+    };
+}
+async function currentWorkItemContent(journal, resources, workItemId) {
+    const primary = (await resources.correlationsForWork(workItemId)).find((correlation) => correlation.role === ResourceCorrelationRole.Primary);
+    if (primary === undefined)
+        return emptyWorkItemContent;
+    const resource = await resources.get(primary.resourceId);
+    if (resource === null)
+        return emptyWorkItemContent;
+    const adapter = parseAdapterId(resource.externalKey.adapter);
+    if (adapter === null)
+        return emptyWorkItemContent;
+    return latestWorkObservedContent(await journal.readStream(integrationStream(adapter)), adapter, resource.externalKey.key);
+}
+const emptyWorkItemContent = { title: '', body: '' };
+function latestWorkObservedContent(events, adapter, externalKey) {
+    let current;
+    for (const event of events) {
+        const observed = selectGitHubAdapterEvent(event);
+        if (!isCurrentWorkObservedEvent(observed, adapter, externalKey))
+            continue;
+        current = observed.payload;
+    }
+    return current ?? emptyWorkItemContent;
+}
+function isCurrentWorkObservedEvent(observed, adapter, externalKey) {
+    return (observed?.eventType === GitHubEventType.WorkObserved &&
+        observed.stream.id === adapter &&
+        observed.source.id === adapter &&
+        observed.payload.externalKey === externalKey);
+}
+function parseAdapterId(value) {
+    try {
+        return adapterId(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/integrations/github/application/agent-run-comment.js

@@ -0,0 +1,94 @@
+export function formatAgentRunComment(value) {
+    const details = detailsLine(value);
+    const sections = [
+        '<!-- wake:agent -->',
+        `<!-- wake:delivery:${value.idempotencyKey} -->`,
+        `**Wake** _(Wake${details ? ` - ${details}` : ''})_`,
+        `**Outcome:** ${value.awaitingApproval === true ? '⏳ Awaiting approval' : outcome(value.outcome)}`,
+        value.displayBody.trim() || fallback(value.outcome),
+    ];
+    if (value.awaitingApproval === true)
+        sections.push('_To approve this work, reply with /approved. To request changes, reply with /changes followed by your feedback. To ask a question without requesting changes, reply with /ask followed by your question._');
+    if (value.outcome === 'BLOCKED')
+        sections.push('_Reply on this thread to continue. To request changes instead, reply with /changes followed by your feedback._');
+    const session = sessionSection(value);
+    if (session !== undefined)
+        sections.push(session);
+    const marker = watchGateMarkerSection(value);
+    if (marker !== undefined)
+        sections.push(marker);
+    return sections.join('\n\n');
+}
+function watchGateMarkerSection(value) {
+    if (value.watchGateVerdict === undefined)
+        return undefined;
+    const marker = {
+        wake: {
+            watchGateVerdict: {
+                runId: value.watchGateVerdict.runId,
+                outcome: value.outcome,
+            },
+        },
+    };
+    return ['```json', JSON.stringify(marker, null, 2), '```'].join('\n');
+}
+function detailsLine(value) {
+    const duration = value.startedAt === undefined || value.finishedAt === undefined
+        ? undefined
+        : formatDuration(new Date(value.finishedAt).getTime() - new Date(value.startedAt).getTime());
+    return [
+        value.stage && `stage \`${value.stage}\``,
+        value.runner && `runner \`${value.runner}\``,
+        value.runnerPool && `runnerPool \`${value.runnerPool}\``,
+        value.cli && `cli ${value.cli}`,
+        value.model && `model \`${value.model}\``,
+        duration && `duration ${duration}`,
+        tokens(value.metadata),
+        cost(value.metadata),
+        value.runId && `run \`${value.runId}\``,
+    ]
+        .filter(Boolean)
+        .join(' - ');
+}
+function sessionSection(value) {
+    if (value.sessionId === undefined)
+        return undefined;
+    const resume = value.workspacePath === undefined
+        ? `codex resume ${value.sessionId}`
+        : `cd "${value.workspacePath}"\ncodex resume ${value.sessionId}`;
+    return [
+        '---',
+        '_Next steps: reply on this thread to continue, or resume this exact Wake session locally:_',
+        '```',
+        resume,
+        '```',
+    ].join('\n');
+}
+function outcome(value) {
+    return {
+        DONE: '\u2705 Done',
+        REJECTED: '\u{1F534} Changes Requested',
+        BLOCKED: '\u{1F7E0} Blocked',
+        FAILED: '\u274C Failed',
+    }[value];
+}
+function fallback(value) {
+    return {
+        DONE: 'Run completed.',
+        REJECTED: 'Run rejected - needs changes.',
+        BLOCKED: 'Run blocked - needs input.',
+        FAILED: 'Run failed.',
+    }[value];
+}
+function tokens(metadata) {
+    const input = metadata.inputTokens, output = metadata.outputTokens;
+    return typeof input === 'number' || typeof output === 'number'
+        ? `tokens ${Number(input ?? 0) + Number(output ?? 0)}`
+        : undefined;
+}
+function cost(metadata) {
+    return typeof metadata.costUsd === 'number' ? `cost $${metadata.costUsd.toFixed(2)}` : undefined;
+}
+function formatDuration(value) {
+    return `${Math.max(0, Math.round(value / 1000))}s`;
+}

package/dist/src/integrations/github/application/comment-history-reader.js

@@ -0,0 +1,43 @@
+import { ResourceCorrelationRole } from '../../../resources/index.js';
+import { adapterId } from '../../contracts/identifiers.js';
+import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
+export function createCommentHistoryReader(journal, resources) {
+    return {
+        async forWorkItem(workItemId) {
+            const keys = new Set((await Promise.all((await resources.correlationsForWork(workItemId))
+                .filter((correlation) => correlation.role === ResourceCorrelationRole.Primary)
+                .map((correlation) => resources.get(correlation.resourceId)))).flatMap((resource) => {
+                if (resource === null || parseAdapterId(resource.externalKey.adapter) === null)
+                    return [];
+                return [`${resource.externalKey.adapter}:${resource.externalKey.key}`];
+            }));
+            if (keys.size === 0)
+                return [];
+            return (await journal.readAll(0)).flatMap((event) => {
+                const observed = selectGitHubAdapterEvent(event);
+                if (observed?.eventType !== GitHubEventType.CommentObserved)
+                    return [];
+                if (!keys.has(`${observed.stream.id}:${observed.payload.externalKey}`))
+                    return [];
+                return [
+                    {
+                        author: observed.payload.actor.id,
+                        occurredAt: observed.occurredAt,
+                        body: observed.payload.body,
+                        ...(observed.payload.reviewKind !== 'issue' || observed.payload.location === undefined
+                            ? {}
+                            : { location: observed.payload.location }),
+                    },
+                ];
+            });
+        },
+    };
+}
+function parseAdapterId(value) {
+    try {
+        return adapterId(value);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/integrations/github/application/inbound-context.js

@@ -0,0 +1,10 @@
+import { correlationId, EventActorKind } from '../../../kernel/index.js';
+import { GitHubAdapter } from '../contracts/vocabulary.js';
+export function commandContext(event) {
+    return {
+        commandId: `${event.eventId}:inbound`,
+        correlationId: correlationId(event.correlationId),
+        occurredAt: event.occurredAt,
+        actor: { kind: EventActorKind.Integration, id: GitHubAdapter },
+    };
+}

package/dist/src/integrations/github/application/inbound-review-signals.js

@@ -0,0 +1,159 @@
+import { ActivityOutcomeKind, ReviewActorKind, ReviewDecisionKind, ReviewerAuthorizationSource, createPullRequestService, } from '../../../activities/index.js';
+import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resourceId, } from '../../../resources/index.js';
+import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
+import { commandContext } from './inbound-context.js';
+import { translateGitHubReviewCommand } from './review-command-translator.js';
+export async function applyReviewSignal(input) {
+    const { event, journal, resources, work, lookup, adapter, orchestration } = input;
+    if (journal === undefined || resources === undefined || work === undefined)
+        return;
+    const payload = event.payload;
+    if (payload.reviewKind === 'issue') {
+        await applyIssueReviewSignal({ event, resources, lookup, orchestration, adapter });
+        return;
+    }
+    await applyFormalReviewSignal({ ...input, journal, resources, work });
+}
+async function applyFormalReviewSignal(input) {
+    const { event, journal, resources, work, lookup, pullRequests, ids, adapter, orchestration } = input;
+    const payload = event.payload;
+    if (payload.reviewKind !== 'formal')
+        return;
+    if (lookup === undefined)
+        throw new Error('InboundTranslator lookup is required');
+    let resourceIdValue = await lookup.resourceIdForExternalKey({
+        adapter,
+        key: payload.externalKey,
+    });
+    if (resourceIdValue === null)
+        resourceIdValue = resourceId(ids.next(ResourceStreamKind.Resource));
+    const proposed = translateGitHubReviewCommand({
+        resourceId: resourceIdValue,
+        revision: payload.revision,
+        actorId: payload.actor.id,
+        actorKind: payload.actor.kind,
+        resourceAuthorId: payload.resourceAuthorId ?? UnknownGitHubIdentity,
+        authorization: payload.authorization ?? { source: ReviewerAuthorizationSource.None },
+        providerEventId: event.eventId,
+        body: payload.body,
+    });
+    if (proposed === null)
+        return;
+    const context = commandContext(event);
+    const pullRequestService = pullRequests ?? createPullRequestService(journal, work, resources);
+    if (proposed.kind === ReviewDecisionKind.Accepted)
+        await pullRequestService.acceptReviewSignal({ ...proposed, origin: 'provider-native-review', acceptedEventId: proposed.providerEventId }, context);
+    else
+        await pullRequestService.requestChangesSignal({ ...proposed, requestedEventId: proposed.providerEventId }, context);
+    await applyPullRequestWorkflowSignal({
+        event,
+        resources,
+        lookup,
+        orchestration,
+        adapter,
+        outcome: proposed.kind === ReviewDecisionKind.Accepted
+            ? ActivityOutcomeKind.Done
+            : ActivityOutcomeKind.Rejected,
+    });
+}
+async function applyIssueReviewSignal(input) {
+    const { event, resources, lookup, orchestration, adapter } = input;
+    if (event.payload.actor.kind !== ReviewActorKind.Human || isWakeDelivery(event.payload.body))
+        return;
+    if (resources === undefined || lookup === undefined || orchestration === undefined)
+        return;
+    const resourceIdValue = await lookup.resourceIdForExternalKey({
+        adapter,
+        key: event.payload.externalKey,
+    });
+    if (resourceIdValue === null)
+        return;
+    const resource = await resources.get(resourceIdValue);
+    if (resource?.kind === BuiltInResourceKind.PullRequest) {
+        await applyWorkflowSignal({
+            event,
+            resources,
+            orchestration,
+            resourceId: resourceIdValue,
+            outcome: recognizedCommand(event.payload.body) === '/approved'
+                ? ActivityOutcomeKind.Done
+                : ActivityOutcomeKind.Rejected,
+        });
+        return;
+    }
+    const command = recognizedCommand(event.payload.body);
+    if (command !== null)
+        await applyIssueApprovalSignal({ ...input, command });
+}
+async function applyIssueApprovalSignal(input) {
+    const { event, command, resources, lookup, orchestration, adapter } = input;
+    if (resources === undefined || lookup === undefined || orchestration === undefined)
+        return;
+    const resourceIdValue = await lookup.resourceIdForExternalKey({
+        adapter,
+        key: event.payload.externalKey,
+    });
+    if (resourceIdValue === null)
+        return;
+    await applyWorkflowSignal({
+        event,
+        resources,
+        orchestration,
+        resourceId: resourceIdValue,
+        outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
+    });
+}
+async function applyPullRequestWorkflowSignal(input) {
+    const { event, lookup, resources, orchestration, adapter, outcome } = input;
+    if (event.payload.actor.kind !== ReviewActorKind.Human ||
+        lookup === undefined ||
+        resources === undefined ||
+        orchestration === undefined)
+        return;
+    const resourceIdValue = await lookup.resourceIdForExternalKey({
+        adapter,
+        key: event.payload.externalKey,
+    });
+    if (resourceIdValue === null)
+        return;
+    await applyWorkflowSignal({
+        event,
+        resources,
+        orchestration,
+        resourceId: resourceIdValue,
+        outcome,
+    });
+}
+async function applyWorkflowSignal(input) {
+    const { event, resources, orchestration, resourceId: resourceIdValue, outcome } = input;
+    const workItemIds = (await resources.correlations(resourceIdValue))
+        .filter((correlation) => correlation.role === ResourceCorrelationRole.Primary)
+        .map((correlation) => correlation.workItemId);
+    for (const workflow of await orchestration.listAll()) {
+        if (!workItemIds.includes(workflow.workItemId))
+            continue;
+        if (workflow.waitingFor === undefined)
+            continue;
+        await orchestration.acceptSignal(workflow.workflowInstanceId, {
+            kind: workflow.waitingFor.signalKind,
+            outcome,
+            actorId: event.payload.actor.id,
+            actorDecision: {
+                authorized: event.payload.actor.kind === ReviewActorKind.Human,
+                evidenceId: event.eventId,
+            },
+            providerEventId: event.eventId,
+        }, commandContext(event));
+    }
+}
+function isWakeDelivery(body) {
+    return body.includes('<!-- wake:');
+}
+function recognizedCommand(body) {
+    const normalized = body.trim().toLowerCase();
+    if (normalized === '/approved')
+        return '/approved';
+    if (normalized === '/changes' || normalized.startsWith('/changes '))
+        return '/changes';
+    return null;
+}