export let config: Config;

  export let path: string;

  export let profile: Profile | null = null;

  export let org: string | null = null;

  // When the component is loaded the first time, the blob is yet to be loaded.

  let state: State = { status: Status.Idle };

    const blob = await loadBlob(path);

    getBlob = new Promise(resolve => resolve(blob));

  };

  const fetchTree = async (path: string) => {

  // This is reactive to respond to path changes that don't originate from this

  // component, eg. when using the browser's "back" button.

  $: getBlob = loadBlob(path);

  $: loadingPath = state.status == Status.Loading ? state.path : null;

</script>

  {:then tree}

    <header>

      <div class="commit">

      </div>

      <div class="anchor">

          {#await getAnchor}

            <Loading small margins />

          {:then anchor}

            {#if anchor === commit}

              <span class="anchor-widget">

              </span>

            {:else}

              <span class="anchor-widget not-anchored">

<Route path="/orgs/:org/projects/:urn" let:params>

  <View {config} org={params.org} urn={params.urn} path="/" />

</Route>

  import Modal from '@app/Modal.svelte';

  import Avatar from '@app/Avatar.svelte';

  import { Org } from '@app/base/orgs/Org';

  import type { Info } from '@app/project';

  import { formatOrg, isAddressEqual } from '@app/utils';

  export let urn: string;

  export let org = "";

  export let commit = "";

  export let config: Config;

  export let path: string;

  let getProject = new Promise<Profile | null>(resolve => {

    if (org) {

      Org.getProjectProfile(org, config).then(p => resolve(p));

    } else {

      resolve(null);

    }

    const cfg = seedHost ? config.withSeed(seedHost, seedId) : config;

    const info = await proj.getInfo(urn, cfg);

    projectInfo = info;

  });

  const parentUrl = (profile: Profile) => {

      ? `/orgs/${profile.nameOrAddress}`

      : `/users/${profile.nameOrAddress}`;

  };

  {:then result}

    <header>

      <div class="title bold">

          </a>

          <span class="divider">/</span>

        {/if}

      <div class="urn">{urn}</div>

      <div class="description">{result.project.meta.description}</div>

    </header>

      commit={commit || result.project.head}

      config={result.config} />

  {:catch}

  export let project: proj.Project;

  export let config: Config;

  let state: State = { status: Status.Loading };

  let info: proj.Info | null = null;

        proj.path({

          urn: project.id,

          org,

          commit: project.anchor.stateHash,

        })

      );

        { name: "seed.id", label: "Seed ID", validate: "id", placeholder: "hynkyndc6w3p8urucakobzncqny7xxtw88...",

          description: "The Device ID of a Radicle Link node that hosts entities associated with this name.",

          value: r.profile.seedId, editable: true },

      ];

      state = { status: Status.Found, registration: r, owner };

    } else {

  address: string | null;

  seedId: string | null;

  seedHost: string | null;

  url: string | null;

  avatar: string | null;

  twitter: string | null;

    resolver.getText('url'),

    resolver.getText('eth.radicle.seed.id'),

    resolver.getText('eth.radicle.seed.host'),

    resolver.getText('com.twitter'),

    resolver.getText('com.github'),

  ]);

    meta.map(r => r.status == "fulfilled" ? r.value : null);

  return {

      avatar,

      seedId,

      seedHost,

      address,

      twitter,

      github,

  return resolver.getText('eth.radicle.seed.id');

}

export function registrar(config: Config): ethers.Contract {

  return new ethers.Contract(config.registrar.address, config.abi.registrar, config.provider);

}

        break;

      case "seed.id":

      case "seed.host":

        calls.push(

          iface.encodeFunctionData("setText", [node, "eth.radicle." + r.name, r.value])

        );

      <div class="fields">

        <!-- Address -->

        <div class="label">Address</div>

        <div></div>

        <!-- Profile -->

        <div class="label">Profile</div>

        <div>

        </div>

      </div>

      <div class="projects">

      </div>

  </main>

{/await}

    return this.profile?.ens?.seedId ?? undefined;

  }

  // Get the name, and if not available, the address.

  get nameOrAddress(): string {

    return this.name ?? this.address;

}

export function path(

): string {

  const result = [];

  if (org) {

    result.push("orgs", org);

  }

  result.push("projects", urn);

import config from "@app/config.json";

import { assert } from '@app/error';

import type { EnsProfile } from "@app/base/registrations/registrar";

import type { BasicProfile } from "@ceramicstudio/idx-constants";

import { ProfileType } from '@app/profile';

      if (profileType === ProfileType.Project) {

        promises.push(getSeedHost(name, config, resolver));

        promises.push(getSeedId(name, config, resolver));

      } else if (profileType === ProfileType.Minimal) {

        promises.push(Promise.resolve(null));

      }

      const project = await Promise.allSettled(promises);

        project.map(r => r.status == "fulfilled" ? r.value : null);

      return {

        address,

        seedHost,

        seedId,

        url: null,

        twitter: null,

        github: null,