@oxy.so/federation 1.0.0

package/src/__tests__/actorObject.test.ts

@@ -0,0 +1,258 @@
+import { ACCOUNT_KINDS } from '@oxy.so/contracts';
+import {
+  AP_CONTEXT,
+  createLocalActorBuilder,
+  createUrlBuilders,
+  AP_ACTOR_TYPES,
+  isApActorType,
+  LOCAL_ACTOR_TYPE_BY_ACCOUNT_KIND,
+  localActorTypeForAccountKind,
+  type ActorMediaResolver,
+} from '../index';
+
+/**
+ * GOLDEN VECTOR — the exact `Person` actor document the engine emits.
+ *
+ * The bytes of this document are load-bearing: Mastodon negative-caches a
+ * malformed actor for minutes/hours, so ANY drift in the field set, key ORDER,
+ * `@context` terms, URL shapes, or the `publicKey` (id host == actor host) can
+ * silently kill discovery ecosystem-wide. This vector is byte-frozen against the
+ * proven live `/ap/users/nate` actor shape; a change here that is not intentional
+ * is a federation break, not a test to "fix".
+ */
+
+/** A media resolver that returns fixed absolute CDN URLs (avatar png, banner jpg). */
+const media: ActorMediaResolver = {
+  resolveAvatar: (ref) => (ref === 'avatar-file-id' ? 'https://cloud.oxy.so/media/nate-avatar.png' : undefined),
+  resolveBanner: (ref) => (ref === 'banner-file-id' ? 'https://cloud.oxy.so/media/nate-banner.jpg' : undefined),
+};
+
+const buildActor = createLocalActorBuilder({
+  domain: 'mention.earth',
+  urls: createUrlBuilders('mention.earth'),
+  media,
+});
+
+const PUBLIC_KEY_PEM =
+  '-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\n-----END PUBLIC KEY-----\n';
+
+const PARAMS = {
+  username: 'nate',
+  displayName: 'Nate',
+  bio: 'building the fediverse',
+  avatar: 'avatar-file-id',
+  profileHeaderImage: 'banner-file-id',
+  publicKey: {
+    keyId: 'https://mention.earth/ap/users/nate#main-key',
+    publicKeyPem: PUBLIC_KEY_PEM,
+  },
+  createdAt: '2023-01-15T10:30:00.000Z',
+} as const;
+
+/**
+ * The frozen expected actor, in the EXACT key order the builder emits. `toEqual`
+ * checks values; the `JSON.stringify` string check locks the serialization order.
+ */
+const EXPECTED_ACTOR: Record<string, unknown> = {
+  id: 'https://mention.earth/ap/users/nate',
+  type: 'Person',
+  preferredUsername: 'nate',
+  name: 'Nate',
+  summary: 'building the fediverse',
+  url: 'https://mention.earth/@nate',
+  inbox: 'https://mention.earth/ap/users/nate/inbox',
+  outbox: 'https://mention.earth/ap/users/nate/outbox',
+  featured: 'https://mention.earth/ap/users/nate/collections/featured',
+  followers: 'https://mention.earth/ap/users/nate/followers',
+  following: 'https://mention.earth/ap/users/nate/following',
+  endpoints: { sharedInbox: 'https://mention.earth/ap/inbox' },
+  discoverable: true,
+  manuallyApprovesFollowers: false,
+  icon: { type: 'Image', url: 'https://cloud.oxy.so/media/nate-avatar.png', mediaType: 'image/png' },
+  image: { type: 'Image', url: 'https://cloud.oxy.so/media/nate-banner.jpg', mediaType: 'image/jpeg' },
+  publicKey: {
+    id: 'https://mention.earth/ap/users/nate#main-key',
+    owner: 'https://mention.earth/ap/users/nate',
+    publicKeyPem: PUBLIC_KEY_PEM,
+  },
+  published: '2023-01-15T10:30:00.000Z',
+};
+
+describe('createLocalActorBuilder (golden actor vector)', () => {
+  it('emits the byte-identical Person actor for a fixed user', () => {
+    const actor = buildActor(PARAMS);
+    expect(actor).toEqual(EXPECTED_ACTOR);
+    // Byte-identity: the serialized bytes (key order included) must match exactly.
+    expect(JSON.stringify(actor)).toBe(JSON.stringify(EXPECTED_ACTOR));
+  });
+
+  it('serves the byte-identical document once wrapped in the route @context', () => {
+    const served = { '@context': AP_CONTEXT, ...buildActor(PARAMS) };
+    expect(JSON.stringify(served)).toBe(JSON.stringify({ '@context': AP_CONTEXT, ...EXPECTED_ACTOR }));
+    // publicKey.id host MUST equal the actor id host (Mastodon rejects a cross-domain key).
+    const key = served.publicKey as { id: string };
+    expect(new URL(key.id).host).toBe(new URL(served.id as string).host);
+  });
+
+  it('pins the load-bearing @context term declarations', () => {
+    expect(AP_CONTEXT[0]).toBe('https://www.w3.org/ns/activitystreams');
+    expect(AP_CONTEXT[1]).toBe('https://w3id.org/security/v1');
+    expect(AP_CONTEXT[2]).toMatchObject({
+      sensitive: 'as:sensitive',
+      toot: 'http://joinmastodon.org/ns#',
+      votersCount: 'toot:votersCount',
+      quote: { '@id': 'https://w3id.org/fep/044f#quote', '@type': '@id' },
+    });
+  });
+
+  it('omits icon/image (but keeps the account valid) when media does not resolve to an absolute URL', () => {
+    const warnings: string[] = [];
+    const strictBuilder = createLocalActorBuilder({
+      domain: 'mention.earth',
+      urls: createUrlBuilders('mention.earth'),
+      media: { resolveAvatar: () => undefined, resolveBanner: () => 'not-an-absolute-url' },
+      onWarn: (m) => warnings.push(m),
+    });
+    const actor = strictBuilder({ ...PARAMS, avatar: null, profileHeaderImage: 'y' });
+    expect(actor.icon).toBeUndefined();
+    expect(actor.image).toBeUndefined();
+    // A non-absolute banner is warned; an absent avatar is not (nothing to resolve).
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('Omitting actor image');
+    expect(JSON.stringify(actor)).not.toContain('"icon"');
+    expect(JSON.stringify(actor)).not.toContain('"image"');
+  });
+});
+
+/**
+ * The RECOGNITION vocabulary, which is a different question from what we emit:
+ * an inbound `Update` carrying a profile is dispatched on it, so a type missing
+ * here means that class of account's profile edits are applied to NOTHING, with
+ * no error raised anywhere.
+ *
+ * `Group` and `Organization` are the two that matter and the two most likely to
+ * be "tidied" out, since this engine never emits `Group` at all: a Lemmy
+ * community IS a `Group`, and a Mention channel is now an `Organization`.
+ */
+describe('AS2 actor recognition vocabulary', () => {
+  it('recognizes all five AS2 actor types', () => {
+    expect([...AP_ACTOR_TYPES].sort()).toEqual([
+      'Application',
+      'Group',
+      'Organization',
+      'Person',
+      'Service',
+    ]);
+    for (const type of AP_ACTOR_TYPES) {
+      expect(isApActorType(type)).toBe(true);
+    }
+  });
+
+  it('separates actors from the content objects sharing the dispatch', () => {
+    // The inbound Update handler is `if (Note|Article) … else if (isApActorType)`,
+    // so a predicate that answered true for content would route an edited post
+    // into an actor refetch.
+    expect(isApActorType('Note')).toBe(false);
+    expect(isApActorType('Article')).toBe(false);
+    expect(isApActorType(undefined)).toBe(false);
+    expect(isApActorType('person')).toBe(false);
+  });
+
+  it('covers every type the emitted subset draws from', () => {
+    for (const emitted of Object.values(LOCAL_ACTOR_TYPE_BY_ACCOUNT_KIND)) {
+      expect(isApActorType(emitted)).toBe(true);
+    }
+  });
+});
+
+/**
+ * The actor `type` is the ONE field that varies by account kind, and it is a
+ * public claim about what an account IS — a `Person` is a human being. These
+ * assertions are written so that a mapping which collapsed to a single constant
+ * (the easiest way to break this by accident) cannot pass:
+ *
+ *  - the per-kind table names BOTH sides of every branch, so a fixture set made
+ *    only of channels could not tell "channels are Service" from "everything is
+ *    Service";
+ *  - the coverage assertion is driven by contracts' own `ACCOUNT_KINDS`, so a
+ *    kind added upstream fails here rather than silently inheriting `Person`;
+ *  - the distinct-value floor fails any constant mapping outright.
+ */
+describe('actor type by Oxy account kind', () => {
+  it('maps each kind to the AS2 type announced for it', () => {
+    expect(localActorTypeForAccountKind('personal')).toBe('Person');
+    expect(localActorTypeForAccountKind('organization')).toBe('Organization');
+    expect(localActorTypeForAccountKind('project')).toBe('Organization');
+    expect(localActorTypeForAccountKind('bot')).toBe('Service');
+    expect(localActorTypeForAccountKind('channel')).toBe('Organization');
+  });
+
+  it('never announces a human-curated channel as automated', () => {
+    // `Service` is what Mastodon writes for "this is an automated account"
+    // (account.rb:224) and is half of `bot?` (account.rb:90) — the Automated
+    // badge, the SimilarProfilesSource exclusion and Lemmy's `bot_account`.
+    // A channel is curated by people; only `bot` may claim automation.
+    expect(localActorTypeForAccountKind('channel')).not.toBe('Service');
+    expect(localActorTypeForAccountKind('bot')).toBe('Service');
+    // `Group` is never emitted for anything: Lemmy would reclassify the actor as
+    // a community that silently never receives content, and PeerTube rejects a
+    // `Group` lacking `attributedTo` outright.
+    expect(Object.values(LOCAL_ACTOR_TYPE_BY_ACCOUNT_KIND)).not.toContain('Group');
+  });
+
+  it('covers every account kind contracts defines, with more than one answer', () => {
+    // Coverage: driven by the upstream vocabulary, so a new kind fails here.
+    expect(Object.keys(LOCAL_ACTOR_TYPE_BY_ACCOUNT_KIND).sort()).toEqual([...ACCOUNT_KINDS].sort());
+    // Vacuity floor: a mapping that returned one constant would pass every
+    // single-kind assertion above and fail this.
+    const answers = ACCOUNT_KINDS.map((kind) => localActorTypeForAccountKind(kind));
+    expect(new Set(answers).size).toBe(3);
+    // And specifically: the two kinds either side of the channel decision differ.
+    expect(localActorTypeForAccountKind('channel')).not.toBe(
+      localActorTypeForAccountKind('personal'),
+    );
+  });
+
+  it('falls back to Person for an absent, null, or unrecognized kind', () => {
+    expect(localActorTypeForAccountKind(undefined)).toBe('Person');
+    expect(localActorTypeForAccountKind(null)).toBe('Person');
+    // Version skew: an Oxy API that knows a kind this package does not must not
+    // produce `type: undefined` — a malformed actor Mastodon negative-caches.
+    expect(localActorTypeForAccountKind('venue')).toBe('Person');
+    expect(localActorTypeForAccountKind(7)).toBe('Person');
+  });
+
+  it('emits the kind-derived type from the builder, keeping key order frozen', () => {
+    // A channel: NOT a person, and the whole point of the change.
+    const channel = buildActor({ ...PARAMS, kind: 'channel' });
+    expect(channel.type).toBe('Organization');
+    // The other side of the branch — without this the assertion above would hold
+    // just as well for a builder that hardcoded 'Organization'.
+    const personal = buildActor({ ...PARAMS, kind: 'personal' });
+    expect(personal.type).toBe('Person');
+    expect(buildActor({ ...PARAMS, kind: 'bot' }).type).toBe('Service');
+
+    // `type` is field 2 of the byte-frozen document: only its VALUE may vary.
+    expect(Object.keys(channel)).toEqual(Object.keys(EXPECTED_ACTOR));
+    expect(Object.keys(channel)[1]).toBe('type');
+    expect(JSON.stringify(channel)).toBe(
+      JSON.stringify({ ...EXPECTED_ACTOR, type: 'Organization' }),
+    );
+  });
+
+  it('leaves an actor with no kind byte-identical to the pre-change document', () => {
+    // The golden vector's PARAMS carries no `kind` — the regression guard that
+    // this change is inert for every ordinary account already federated.
+    expect(buildActor(PARAMS).type).toBe('Person');
+    expect(JSON.stringify(buildActor(PARAMS))).toBe(JSON.stringify(EXPECTED_ACTOR));
+  });
+});
+
+describe('createUrlBuilders', () => {
+  it('scopes actor() to actorDomain and the rest to domain', () => {
+    const urls = createUrlBuilders('mention.earth', 'actors.mention.earth');
+    expect(urls.actor('nate')).toBe('https://actors.mention.earth/ap/users/nate');
+    expect(urls.inbox('nate')).toBe('https://mention.earth/ap/users/nate/inbox');
+    expect(urls.sharedInbox()).toBe('https://mention.earth/ap/inbox');
+  });
+});

package/src/__tests__/actorResolver.test.ts

@@ -0,0 +1,252 @@
+import { createDomainPolicy } from '../apUri';
+import { createActorResolver, type ActorResolverConfig, type FederatedActorRecordBase } from '../node/actorResolver';
+
+/**
+ * The instance domain policy applies to CACHED actors, not just fetched ones.
+ *
+ * `fetchRemoteActor` has always refused a blocked host before doing network I/O,
+ * but `getOrFetchActor` served its cache hit above that check — so for every
+ * instance we had already stored an actor for (which is every instance that has
+ * ever reached us), adding its domain to the blocklist changed nothing at all.
+ * These lock the cached branch closed and prove the fetching branch still works.
+ */
+
+interface TestActor extends FederatedActorRecordBase {
+  uri: string;
+}
+
+const BLOCKED_ACTOR = 'https://spam.example/users/mallory';
+const ALLOWED_ACTOR = 'https://remote.example/users/bob';
+
+function makeResolver(
+  overrides: {
+    cached?: TestActor | null;
+    cachedKey?: Pick<TestActor, 'uri' | 'publicKeyPem'> | null;
+    blockedHosts?: string[];
+    signedFetch?: (url: string) => Promise<Response>;
+  } = {},
+) {
+  const blockedHosts = overrides.blockedHosts ?? ['spam.example'];
+  const domainPolicy = createDomainPolicy({
+    domain: 'mention.earth',
+    blockedDomains: blockedHosts,
+  });
+  const findActorByUriCalls: string[] = [];
+  const signedFetchCalls: string[] = [];
+
+  const config: ActorResolverConfig<TestActor> = {
+    federationEnabled: true,
+    signedFetch: async (url) => {
+      signedFetchCalls.push(url);
+      if (overrides.signedFetch) return overrides.signedFetch(url);
+      // A 404 ends `fetchRemoteActor` without exercising the parse/upsert path;
+      // these tests only care about WHETHER the fetch was attempted.
+      return new Response(null, { status: 404 });
+    },
+    fetchWebFinger: async () => null,
+    isBlockedDomain: domainPolicy.isBlockedDomain,
+    normalizeFederatedAcct: (acct) => acct,
+    domainFromAcct: (acct) => acct.split('@')[1],
+    firstStringUrl: () => undefined,
+    store: {
+      findActorByUri: async (uri) => {
+        findActorByUriCalls.push(uri);
+        return overrides.cached ?? null;
+      },
+      upsertActor: async () => null,
+      findActorByPublicKeyId: async () => overrides.cachedKey ?? null,
+      setActorOxyUserId: async () => {},
+      tombstoneActor: async () => null,
+    },
+    identity: {
+      resolveExternalUser: async () => null,
+      reportActorGone: async () => 'archived',
+    },
+    text: {
+      inlineField: (value) => (typeof value === 'string' ? value : ''),
+      inlineDisplayName: (raw) => raw,
+      sanitizeFieldValue: (html) => html,
+      htmlToPlainText: (html) => html,
+    },
+    logger: { info: () => {}, warn: () => {} },
+  };
+
+  return { resolver: createActorResolver(config), findActorByUriCalls, signedFetchCalls };
+}
+
+/**
+ * A response whose body is pulled lazily, so the test can see HOW MUCH of it the
+ * reader asked for.
+ *
+ * `pulls` and not a `cancel()` flag on purpose. The property under test is that
+ * an oversized body is not DRAINED — that the reader stops early instead of
+ * buffering whatever a hostile instance sends. Whether the source stream's
+ * `cancel()` callback fires is a different question, and one this environment
+ * cannot answer: under jest, `reader.cancel()` does not propagate to the
+ * underlying source, while the same code in plain Node does. Asserting on it
+ * would be asserting on the harness.
+ *
+ * `pulls` is observable either way, and it is the thing that actually bounds
+ * the work: a reader that stopped at the cap has pulled a handful of chunks; one
+ * that drained has pulled all of them.
+ */
+function streamedResponse(chunks: string[], init?: ResponseInit): { response: Response; pulls: () => number } {
+  let pulls = 0;
+  const encoder = new TextEncoder();
+  const response = new Response(new ReadableStream<Uint8Array>({
+    pull(controller) {
+      pulls += 1;
+      const chunk = chunks.shift();
+      if (chunk === undefined) controller.close();
+      else controller.enqueue(encoder.encode(chunk));
+    },
+  }), init);
+  return { response, pulls: () => pulls };
+}
+
+describe('getOrFetchActor — instance domain policy', () => {
+  it('refuses a blocked domain whose actor is ALREADY CACHED', async () => {
+    const rig = makeResolver({ cached: { uri: BLOCKED_ACTOR, lastFetchedAt: new Date() } });
+    await expect(rig.resolver.getOrFetchActor(BLOCKED_ACTOR)).resolves.toBeNull();
+  });
+
+  it('refuses before reading the actor cache at all', async () => {
+    const rig = makeResolver({ cached: { uri: BLOCKED_ACTOR, lastFetchedAt: new Date() } });
+    await rig.resolver.getOrFetchActor(BLOCKED_ACTOR);
+    expect(rig.findActorByUriCalls).toHaveLength(0);
+  });
+
+  // Pre-existing behaviour (`fetchRemoteActor` has always refused a blocked host);
+  // held here so the uncached branch cannot regress alongside the cached one.
+  it('refuses a blocked domain with no cached actor, without any network I/O', async () => {
+    const rig = makeResolver({ cached: null });
+    await expect(rig.resolver.getOrFetchActor(BLOCKED_ACTOR)).resolves.toBeNull();
+    expect(rig.signedFetchCalls).toHaveLength(0);
+  });
+
+  it('refuses a STALE cached row for a blocked domain, and refreshes nothing', async () => {
+    const stale = new Date(Date.now() - 48 * 60 * 60 * 1000);
+    const rig = makeResolver({ cached: { uri: BLOCKED_ACTOR, lastFetchedAt: stale } });
+    // Staleness used to pick the background-refresh branch and STILL hand the
+    // caller the cached row; the row must now not be returned at all.
+    await expect(rig.resolver.getOrFetchActor(BLOCKED_ACTOR)).resolves.toBeNull();
+    // Let any detached refresh promise settle before asserting nothing was sent.
+    await new Promise((resolve) => setImmediate(resolve));
+    expect(rig.signedFetchCalls).toHaveLength(0);
+  });
+
+  it('fails closed on an actor URI with no parseable host', async () => {
+    const rig = makeResolver({ cached: { uri: 'not-a-uri' } });
+    await expect(rig.resolver.getOrFetchActor('not-a-uri')).resolves.toBeNull();
+    expect(rig.findActorByUriCalls).toHaveLength(0);
+  });
+
+  it('still returns a cached actor for an allowed domain', async () => {
+    const cached: TestActor = { uri: ALLOWED_ACTOR, lastFetchedAt: new Date() };
+    const rig = makeResolver({ cached });
+    await expect(rig.resolver.getOrFetchActor(ALLOWED_ACTOR)).resolves.toBe(cached);
+  });
+
+  it('still fetches an allowed domain that is not cached', async () => {
+    const rig = makeResolver({ cached: null });
+    await rig.resolver.getOrFetchActor(ALLOWED_ACTOR);
+    expect(rig.signedFetchCalls).toEqual([ALLOWED_ACTOR]);
+  });
+});
+
+describe('fetchPublicKey — signature lookups stay honest', () => {
+  it('serves a cached key for a blocked domain, so its signature is judged on merit', async () => {
+    const rig = makeResolver({ cachedKey: { uri: BLOCKED_ACTOR, publicKeyPem: 'PEM' } });
+    await expect(rig.resolver.fetchPublicKey(`${BLOCKED_ACTOR}#main-key`)).resolves.toEqual({
+      publicKeyPem: 'PEM',
+      actorUri: BLOCKED_ACTOR,
+    });
+  });
+
+  it('will not resolve a blocked domain key that would require network I/O', async () => {
+    const rig = makeResolver({ cachedKey: null, cached: null });
+    await expect(rig.resolver.fetchPublicKey(`${BLOCKED_ACTOR}#main-key`)).resolves.toBeNull();
+    expect(rig.signedFetchCalls).toHaveLength(0);
+  });
+});
+
+describe('fetchRemoteActor — bounded remote bodies', () => {
+  /**
+   * A body far larger than the cap, in chunks a quarter of it. A reader that
+   * stops at the cap pulls a handful; one that drains pulls all `count`.
+   */
+  function chunked(chunkBytes: number, count: number, init?: ResponseInit) {
+    return streamedResponse(Array.from({ length: count }, () => 'x'.repeat(chunkBytes)), init);
+  }
+
+  it('stops reading an actor body once it exceeds the decompressed-size cap', async () => {
+    // 24 chunks of an eighth-cap each: 3x the cap on offer. Kept modest on
+    // purpose — a body large enough to make the point but not to make an
+    // UNBOUNDED reader die of memory pressure, which would fail this test for
+    // the wrong reason and hide what it measures.
+    const oversized = chunked(128 * 1024, 24);
+    const rig = makeResolver({ signedFetch: async () => oversized.response });
+
+    await expect(rig.resolver.fetchRemoteActor(ALLOWED_ACTOR)).resolves.toBeNull();
+    expect(oversized.pulls()).toBeLessThan(15);
+  });
+
+  it('drains a body that stays under the cap — the bound is what stops it, not an early return', async () => {
+    // Positive control for the three bounds below: without this, a resolver
+    // that had broken into never reading a body at all would satisfy every
+    // `pulls()` assertion here and read as correctly bounded.
+    const actor = JSON.stringify({
+      id: ALLOWED_ACTOR,
+      inbox: 'https://remote.example/inbox',
+      preferredUsername: 'bob',
+    });
+    const small = streamedResponse(actor.match(/.{1,16}/g) ?? []);
+    const rig = makeResolver({ signedFetch: async () => small.response });
+
+    await rig.resolver.fetchRemoteActor(ALLOWED_ACTOR);
+    // Every chunk, plus the pull that closes the stream.
+    expect(small.pulls()).toBeGreaterThan(Math.ceil(actor.length / 16));
+  });
+
+  it('rejects an oversized actor from Content-Length without consuming its stream', async () => {
+    let cancelled = false;
+    const response = new Response(new ReadableStream<Uint8Array>({
+      pull(controller) {
+        controller.enqueue(new Uint8Array([123]));
+      },
+      cancel() {
+        cancelled = true;
+      },
+    }), { headers: { 'content-length': String(1024 * 1024 + 1) } });
+    const rig = makeResolver({ signedFetch: async () => response });
+
+    await expect(rig.resolver.fetchRemoteActor(ALLOWED_ACTOR)).resolves.toBeNull();
+    expect(cancelled).toBe(true);
+  });
+
+  it('bounds actor-advertised collection responses and fails the count soft', async () => {
+    const actor = JSON.stringify({
+      id: ALLOWED_ACTOR,
+      inbox: 'https://remote.example/inbox',
+      preferredUsername: 'bob',
+      followers: 'https://remote.example/followers',
+    });
+    const oversizedCollection = chunked(8 * 1024, 24);
+    const rig = makeResolver({
+      signedFetch: async (url) => url === ALLOWED_ACTOR
+        ? new Response(actor)
+        : oversizedCollection.response,
+    });
+
+    await expect(rig.resolver.fetchRemoteActor(ALLOWED_ACTOR)).resolves.toBeNull();
+    expect(oversizedCollection.pulls()).toBeLessThan(15);
+  });
+
+  it('caps an error body before attempting the WebFinger fallback', async () => {
+    const oversized = chunked(512, 24, { status: 500 });
+    const rig = makeResolver({ signedFetch: async () => oversized.response });
+
+    await expect(rig.resolver.fetchRemoteActor(ALLOWED_ACTOR)).resolves.toBeNull();
+    expect(oversized.pulls()).toBeLessThan(15);
+  });
+});