periplus-map 0.2.1__py3-none-any.whl

periplus/packs/drupal_basic@0.3.0/pack.yaml

@@ -0,0 +1,528 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# The walking-skeleton Drupal pack: every exported or installed configuration file becomes one
+# node. It is renamed to drupal when the reference packs retire.
+#
+# Known gaps. The basic Drupal pack maps, beside php_basic's classes, functions and methods:
+# - configuration, modules, themes, services with their tags and classes, routes, permissions,
+#   libraries, templates, entity types, bundles, fields, displays, menu links, local actions,
+#   block placements and the plugin kinds whose folders are named under folders below. A service's
+#   class may be a class or an interface, as for a service a factory builds;
+# - each bundle under the id <entity type>.<bundle>, as node.article. A bundle config file of a core
+#   prefix declares it with its label, a configured_by edge to that file and a bundle_of edge to
+#   its entity type. A field instance or a display gives a field_of or displays edge to the bundle
+#   its entity type and bundle keys name, and an inferred bundle_of edge from that bundle. A bundle
+#   or an entity type that no rule declares, such as a paragraph type or the ECK entity type
+#   my_type, ends at a referenced node. A field storage gives a storage_of edge to its entity
+#   type, a view or form mode a mode_of edge to its entity type, and a display in a mode other than
+#   default an in_mode edge to that mode;
+# - each service that \Drupal::service('x') names in a PHP function or method, as a uses_service
+#   edge; each service that get('x') or ?->get('x') names on an object written $container,
+#   $this->container, \Drupal::getContainer(), or getContainer() on $this, static or self, as a
+#   uses_service edge with confidence inferred; and each entity type
+#   that \Drupal::entityQuery('x') or \Drupal::entityQueryAggregate('x') names, or that
+#   getStorage('x'), getViewBuilder('x'), getListBuilder('x'), getFormObject('x') or
+#   getAccessControlHandler('x') names on an object written ending in entityTypeManager, written
+#   $entity_type_manager, written as the container's get('entity_type.manager') or
+#   \Drupal::service('entity_type.manager'), or reached through a property of $this whose declared
+#   type is EntityTypeManager or EntityTypeManagerInterface, as a uses_entity_type edge. A service
+#   or an entity type that no mapped file declares, such as config.factory or node, ends at a
+#   referenced node: Drupal core and contributed modules are outside the mapped code;
+# - each method that carries a Hook attribute, and each function in a module, install, inc, theme,
+#   profile, post_update.php or deploy.php file whose name starts with the first part of the file
+#   name and an underscore, as an implements_hook edge to the hook the rest of the name gives:
+#   mymod_cron in mymod.module implements cron, mymod_post_update_fix in mymod.post_update.php
+#   implements post_update_NAME, as every update_N function implements the one hook update_N. A
+#   function in an inc file, or a theme file other than the theme's own, below a custom theme
+#   folder, whose name starts with that folder's name and an underscore, implements a hook the
+#   same way: mytheme_preprocess_node in mytheme/preprocess/node.preprocess.inc or in
+#   mytheme/includes/content.theme implements preprocess_node. A hook found by a
+#   function's name has confidence inferred;
+# - a route's methods, its requirements _access, _format, _user_is_logged_in, _csrf_token,
+#   _entity_access and _custom_access, and its options no_cache and _admin_route, as attributes
+#   holding the value as written; each role its _role names, as a requires_role or accepts_role
+#   edge to user.role.<role>; a _custom_access written service:method as an
+#   access_checked_by_service edge, one written Class::method as an access_checked_by edge; a
+#   _title_callback written Class::method as a titled_by edge; and each parameter typed
+#   entity:<type> as a loads_entity_type edge;
+# - each role's configuration as a role, with its is_admin attribute, and each permission it lists
+#   as a grants_permission edge. A role or permission that no mapped file declares, such as one
+#   from core or a contributed module, ends at a referenced node.;
+# - each route a template names in path('x') or url('x'), as a template_links_route edge, read as
+#   text; a core route such as user.login ends at a referenced node;
+# - each template another template names in an include, extends, embed, import or from, as a
+#   template_includes edge, and each component an include or embed names as theme:name, as a
+#   template_includes_component edge to the component's name. Read as text; a name no mapped
+#   template or component has ends at a referenced node;
+# - each theme hook that a hook_theme function declares, as a drupal.theme_hook node, and the
+#   class or trait under src that gives '#theme' => 'name' in a render array, as a
+#   renders_theme_hook edge to it. A hook links to its template by theme_hook_template: the
+#   template key as declared, and
+#   for a hook with no template and no function key its name with underscores written as dashes,
+#   as inferred. A template named <entity>--<bundle>--<view mode> of node, taxonomy-term,
+#   block-content, paragraph, media or comment gives a suggests_bundle edge to the bundle
+#   <entity>.<bundle>, as inferred.
+# - each simple configuration file, with no top-level uuid, as a config_provided_by edge to the
+#   module its name starts with; each literal form id a form class returns, as a drupal.form_id
+#   node with a form_has_id edge from the class, and each form id a CAPTCHA point or the honeypot
+#   settings name, as a config_names_form edge; each hook named <extension>_<type>_<operation>,
+#   as an inferred hook_acts_on_entity_type edge to <type>; each route's path, as a
+#   route_serves_path edge to a drupal.url_path node, and each path Url::fromUserInput or
+#   Url::fromUri('internal:...') names, as a links_to_path edge. The rule files' headers name
+#   their limits.
+#
+# False results:
+# - A suggests_bundle edge is made whether or not the bundle is mapped: the engine cannot ask. An
+#   unmapped bundle ends at a referenced node.
+# - A hook with a template key kept in a variables default, or an entry whose first key is not a
+#   registry key, reads as no hook or as the wrong one. A hook entry that opens with the key
+#   type, pattern or function is not found. One that opens with path or file is found when a
+#   registry key follows at its own bracket level, so a variable default such as
+#   'link' => ['path' => NULL] does not read as a hook. Inside a hook_theme function, any key
+#   whose array opens with a registry key reads as a hook: 'nested' => ['variables' => NULL]
+#   inside an entry gives the hook nested.
+# - A function name of the form <extension>_<type>_<operation> gives a hook_acts_on_entity_type
+#   edge whether or not <type> is an entity type. On Drupal core, helpers read as the hooks
+#   cookie_delete, mass_update, set_edit_access and translate_access end at the referenced entity
+#   types cookie, mass, set_edit and translate.
+# - Any function whose name starts with the first part of the file name reads as a hook: the form
+#   callback mymod_settings_submit reads as the hook settings_submit, the helper mymod_build_list
+#   as build_list, and mymod_update_NEXT as update_NEXT. The same holds for a theme's inc file
+#   and the theme folder's name. On one site, 8 of 165 hooks were such callbacks or helpers.
+# - The prefix is the file name, not an installed module's name. If Drupal core were inside the
+#   mapped folders, its files such as form.inc would give false hooks, such as select_options from
+#   form_select_options.
+# - A procedural function kept beside a Hook attribute method for the same hook, a LegacyHook shim,
+#   reads as a second implementation of that hook, though Drupal skips the shim.
+# - A function below one that carries the ProceduralHookScanStop attribute, and every function of
+#   a module that sets skip_procedural_hook_scan, still reads as a hook, though Drupal does not
+#   scan them.
+# - A misspelled service or entity type name ends at a referenced node, as a real one from core
+#   does, and not at an unresolved one.
+# - A $container or $this->container that is not Drupal's service container gives a false
+#   service.
+#
+# Missing results:
+# - A '#theme' written in a function, such as a hook in a module file, gives no edge, because the
+#   rule starts it at the class the file path names. A theme hook declared by a method of a class,
+#   or by a hook_theme function that is not named theme or ending in _theme, is not found. A
+#   template named <entity>--<name>.html.twig gives no suggests_bundle edge, because the file
+#   cannot tell a bundle from a view mode or a node id.
+# - A form id is read only from a getFormId() whose body returns a literal text, which gives a
+#   drupal.form_id node and a form_has_id edge. A constant, a concatenation or a variable returned
+#   gives neither.
+# - A template is known by its file stem, and a component by its name without the theme: two
+#   themes that define a component of one name meet at one node, as templates of one name do.
+#   A template or component named by a variable, a concatenation or a list gives no edge. Only
+#   a name ending in .html.twig gives a template edge, and only a .html.twig file is read, so
+#   a component's own .twig and story files give none.
+# - A function in a module file named other than its module, such as includes/helpers.inc
+#   holding mymod_ functions, gives no hook. A theme's inc file, and a theme file named other than
+#   its theme, such as includes/content.theme, is read by the name of the folder directly below
+#   custom_theme, so a theme nested deeper, or one whose folder name is not its machine name,
+#   gives no hook. Nor does a function named with another module's name, such as
+#   othermod_cron in mymod.module, which Drupal counts as a hook of othermod.
+# - The number of an update_N function is not recorded apart from the function's name.
+# - Plugins of the core types not named under folders below give nothing, such as a views
+#   argument, sort or display plugin. A views field, filter or style plugin declared by an
+#   annotation, and a mail plugin declared by an annotation, give nothing. A views plugin gives
+#   one skipped row, argument 0 or id missing, from the rule that reads the other form of the id.
+# - A plugin type itself, its attribute class and its plugin manager service, gets no node.
+# - A hook with a variable part keeps that part in its name: mymod_form_user_login_form_alter
+#   implements form_user_login_form_alter, not form_FORM_ID_alter.
+# - A class that extends ContentEntityBase and carries no ContentEntityType attribute or
+#   annotation, such as an abstract base or a bundle class, reads as a descendant of the boundary
+#   name ContentEntityBase, and is still not marked as an entity class.
+# - A service or entity type named by a variable, a concatenation, or a class constant that no
+#   mapped file declares as text, gives no edge and goes under skipped. So does parent::X, even
+#   when a mapped file declares it: only self and static read as the enclosing class.
+#   getStorage('x') on an object with another name, as $etm, get('x') on a container with another
+#   name, a receiver
+#   written with a space or a line break inside get('entity_type.manager'), and other entity type
+#   manager methods such as getHandler('x') give no edge.
+# - A \Drupal:: shortcut gives a uses_service edge only when the table shortcut_services below
+#   lists its method, and \Drupal::cache('x') gives none. A static load, loadMultiple or create
+#   call gives a uses_entity_type edge only on a core entity class the table entity_classes lists:
+#   MyEntity::loadMultiple() and Message::load(1) give none. Each such call is listed as skipped.
+#   An entity class is known by its short name, so a project class named as a core one, such as
+#   a module's own User class, gives a false uses_entity_type edge.
+# - The container rules read get('x') in lower case only: another letter case, such as
+#   ->GET('x'), gives no edge and no skipped row.
+# - A contributed module's bundle config file, such as paragraphs.paragraphs_type.text or
+#   eck.eck_type.my_type.my_bundle, stays a plain config object. Its bundle is
+#   referenced, with no label and no configured_by edge, and a type that no field or display names
+#   has no bundle node. That module's own rutter maps the file onto the same bundle id.
+# - A display in the mode default has no in_mode edge, because that mode has no config file.
+# - An entity reference field's target bundles, under settings.handler_settings.target_bundles,
+#   give no edge.
+# - A top-level function in a plain .php file in the custom folders, other than a post_update.php
+#   or deploy.php file, makes no hook. Each such file leaves two skipped rows in the report, one
+#   per hook rule, at its first function.
+# - A _custom_access written service:method gives an edge to the service only. The method stays in
+#   the custom_access attribute and gives no edge to a PHP method.
+# - The applies_to key of a service's access_check tag is kept as the service's applies_to
+#   attribute, not on the tagged_as edge, because an attribute on an edge is accepted and not
+#   executed. A custom route requirement that such a tag binds, such as _mymod_access: 'TRUE', is
+#   not read and gives no edge to the service.
+# - A route parameter that Drupal converts to an entity because its name is an entity type, with
+#   no options.parameters type, gives no loads_entity_type edge, nor does a type other than
+#   entity:<type>, such as entity_revision:<type>.
+# - Requirements and options other than those listed above give nothing: _entity_create_access,
+#   _module_dependencies, a parameter's pattern, _auth, _maintenance_access, a custom option, and
+#   the like.
+# - An attribute keeps the value as written, so no_cache: 'TRUE' and no_cache: true give "TRUE"
+#   and true, and is_admin: null gives null.
+#
+# Settings to know:
+# - Only the custom modules and themes are read as PHP. Move them with custom_module and
+#   custom_theme under folders. A folder setting may not leave the project root, so a site is
+#   mapped from inside its own tree or from a copy.
+# - This pack repeats php_basic's PHP grammar pin, because a pack that reads a file type as a tree
+#   must pin the grammar itself. A grammar update must change both packs.
+pack: drupal_basic
+version: 0.3.0
+depends: [yaml_basic, php_basic, twig_basic]
+
+# ======================================================================================
+# DETECTION
+#
+# What makes a checkout a Drupal checkout, so `periplus init` can prefill this pin. The
+# answer is written here rather than in the engine: recognising a stack is pack data, and
+# a pack somebody else wrote is detected exactly the way this one is.
+#
+# Neither signal is "there is PHP here". php_basic, yaml_basic and twig_basic are reached
+# through `depends` and declare no detector of their own, because a repository having PHP
+# in it is not a stack anybody pins.
+#
+# What init writes is a suggestion in a file the person then edits. A missed detection
+# costs them one typed line; a spurious one costs a wrong pin in a committed artifact. So
+# both signals below are things only a Drupal repository has.
+# ======================================================================================
+detect:
+  any_of:
+    # The dependency, which is the claim the repository makes about itself. `drupal/core`
+    # rather than `drupal/core-recommended`: the substring covers core, core-recommended
+    # and core-composer-scaffold, and every Drupal site requires at least one of them.
+    # Verified against drupal-cms/composer.json on 2026-08-28, which requires
+    # drupal/core-composer-scaffold, drupal/core-project-message and
+    # drupal/core-recommended.
+    - path: composer.json
+      contains: "drupal/core"
+
+    # The docroot, for a checkout that has core in the tree and no composer.json at the
+    # root -- core's own repository, and a site vendored without Composer. The filename
+    # alone is the evidence, so this signal needs no `contains`.
+    - path: web/core/lib/Drupal.php
+
+folders:
+  config:        ./config/sync
+  custom_module: ./web/modules/custom
+  custom_theme: ./web/themes/custom
+  # An extension's shipped configuration: config/install and config/optional.
+  module_config:
+  - "{custom_module}/**/config/install"
+  - "{custom_module}/**/config/optional"
+  - "{custom_theme}/**/config/install"
+  - "{custom_theme}/**/config/optional"
+  module_root: "{custom_module}/**"
+  theme_root: "{custom_theme}/**"
+  # php_basic's source, narrowed to the custom modules and themes at any depth.
+  source:
+  - "{custom_module}/**"
+  - "{custom_theme}/**"
+  # The folder a plugin kind is discovered in: the sub-folder its manager names, below a module's
+  # src folder, and every folder below it. A class elsewhere is not discovered. An entity type is
+  # discovered in src/Entity.
+  action_classes: "{module_root}/src/Plugin/Action/**"
+  block_plugin_classes: "{module_root}/src/Plugin/Block/**"
+  constraint_classes: "{module_root}/src/Plugin/Validation/Constraint/**"
+  entity_type_classes: "{module_root}/src/Entity/**"
+  field_formatter_classes: "{module_root}/src/Plugin/Field/FieldFormatter/**"
+  field_type_classes: "{module_root}/src/Plugin/Field/FieldType/**"
+  field_widget_classes: "{module_root}/src/Plugin/Field/FieldWidget/**"
+  mail_classes: "{module_root}/src/Plugin/Mail/**"
+  media_source_classes: "{module_root}/src/Plugin/media/Source/**"
+  queue_worker_classes: "{module_root}/src/Plugin/QueueWorker/**"
+  rest_resource_classes: "{module_root}/src/Plugin/rest/resource/**"
+  views_field_classes: "{module_root}/src/Plugin/views/field/**"
+  views_filter_classes: "{module_root}/src/Plugin/views/filter/**"
+  views_style_classes: "{module_root}/src/Plugin/views/style/**"
+
+files:
+  # The Drupal endings that hold PHP, added to php_basic's list.
+  extends: php_basic
+  add_extensions: [module, install, inc, theme, profile, engine]
+  # The Group module's group.permissions files hold Group permissions, not Drupal permissions, and
+  # their stem also ends in .permissions.
+  exclude:
+  - '**/*.group.permissions.yml'
+  types:
+    # php_basic's type, given the path value extension: the first part of a module, install,
+    # include, theme, profile, post_update.php or deploy.php file's name, which its procedural
+    # hook functions start with. Absent for any other ending. And theme_name: the name of the
+    # folder directly below custom_theme that holds an inc file, or a theme file other than the
+    # theme's own, which a theme's included files name their functions with. A type read as a tree needs its pack to pin the grammar,
+    # php_basic's pin repeated.
+    php:
+      endings: [module, install, inc, theme, profile]
+      reader: tree
+      path_values:
+        extension:
+          pattern: '^(?:.*/)?(?<name>[^/.]+)\.(?:(?:[^/]+\.)?(?:module|install|inc|theme|profile)|post_update\.php|deploy\.php)$'
+          template: '{name}'
+        theme_name:
+          pattern: '^(?<name>[^/]+)/(?!(?P=name)\.theme$)(?:[^/]+/)*[^/]+\.(?:inc|theme)$'
+          template: '{name}'
+          relative_to: custom_theme
+
+    # yaml_basic's type yml, read as data, given the path value config_owner: the first
+    # dot-separated part of a configuration file's name, the module that provides the file when
+    # it is simple configuration. Absent for core.*, which names no module.
+    yml:
+      endings: [yml]
+      reader: data
+      format: yaml
+      path_values:
+        config_owner:
+          pattern: '^(?:.*/)?(?!core\.)(?<owner>[^/.]+)\.[^/]+\.[^/.]+$'
+          template: '{owner}'
+
+    # Two text readings, beside the tree readings twig_basic and php_basic give the same files,
+    # for what a tree rule cannot reach: a call inside a template, the array form of an
+    # attachment, a docblock tag, a class constant used as an array key. Declared here, once,
+    # because the engine lets one text type claim a file ending across all packs; drupal_js_basic,
+    # drush_basic, salesforce_basic and twig_tweak_basic read them.
+    # Templates read as text with their own name as a value, beside the reading twig_basic
+    # gives them. A match that starts inside a Twig comment makes nothing.
+    drupal_template_text:
+      endings: [twig]
+      reader: text
+      path_values:
+        template_name:
+          pattern: '^(?:.*/)?(?<name>[^/]+)\.html\.twig$'
+          template: '{name}'
+        # The bundle an entity template suggestion names, as node.article for
+        # node--article--teaser. Absent for any other name.
+        bundle_suggestion:
+          pattern: '^(?:.*/)?(?<entity>node|taxonomy-term|block-content|paragraph|media|comment)--(?<bundle>[a-z][a-z0-9-]*?)--[a-z0-9]+(?:-[a-z0-9]+)*\.html\.twig$'
+          template: '{entity}.{bundle}'
+          normalize:
+          - {replace: '-', with: '_'}
+      sections:
+      - name: comment
+        open: '\{#'
+        close: '#\}'
+    # PHP read as text, beside the tree reading the PHP packs give it, for the array form of an
+    # attachment. The sections are the comments and the strings. A span is the array after
+    # '#attached' =>, and the array after 'library' =>.
+    drupal_php_text:
+      endings: [php, module, theme, inc, install, profile]
+      reader: text
+      path_values:
+        # The class a file under src holds, by Drupal's PSR-4 layout: <module>/src/A/B.php is
+        # Drupal\<module>\A\B.
+        psr4_class:
+          pattern: '^(?:.*/)?(?<module>[^/]+)/src/(?<rest>.+)\.php$'
+          template: 'Drupal\{module}\{rest}'
+          normalize:
+          - {replace: '/', with: '\'}
+      sections:
+      - name: heredoc
+        open: '<<<[ \t]*["'']?(?<label>[A-Za-z_][A-Za-z0-9_]*)'
+        close: '\n[ \t]*{label}\b'
+      - name: block_comment
+        open: '/\*'
+        close: '\*/'
+      - name: line_comment
+        open: '//'
+        close: '\n'
+      - name: hash_comment
+        open: '#[^\[\n]'
+        close: '\n'
+      - name: string
+        open: ''''
+        close: '(?:[^''\\]|\\(?s:.))*'''
+      - name: string
+        open: '"'
+        close: '(?:[^"\\]|\\(?s:.))*"'
+      spans:
+      - name: attached
+        open: '[\[,(\s][''"](?<mark>#attached)[''"]\s*=>\s*(?=\[)'
+        balance: ['[', ']']
+      - name: library_list
+        open: '[\[,(\s][''"](?<mark>library)[''"]\s*=>\s*(?=\[)'
+        balance: ['[', ']']
+      # The body of a function named theme or ending in _theme, which is where hook_theme returns
+      # its entries.
+      - name: hook_theme_body
+        open: '\b(?<mark>function)\s+(?:\w+_)?theme\s*\([^)]*\)[^{;]*(?=\{)'
+        balance: ['{', '}']
+      # The body of a named function; name is the name as written.
+      - name: function_body
+        open: '\b(?<mark>function)\s+(?<name>\w+)\s*\([^)]*\)[^{;]*(?=\{)'
+        balance: ['{', '}']
+      - name: settings_list
+        open: '[\[,(\s][''"](?<mark>drupalSettings)[''"]\s*=>\s*(?=\[)'
+        balance: ['[', ']']
+
+grammar:
+  provider: tree-sitter
+  provider_version: "0.26.0"
+  language: php
+  grammar_version: "0.24.1"
+  # A call argument written MyType::ENTITY_TYPE, self::X or static::X stands for the text that
+  # constant is declared with, when a mapped file declares it as one text literal. A constant read
+  # as parent::X, of core, of contrib, or declared by an expression gives the row "argument N is a
+  # class constant with no declared text".
+  constant_access:
+    node: class_constant_access_expression
+    scope: [name, qualified_name, relative_scope]
+    name: [name]
+    enclosing: [self, static]
+  constant_declaration:
+    node: const_element
+    name: [name]
+    value: [string, encapsed_string]
+
+# Name tables that call/call.yaml looks a written name up in.
+tables:
+  # Each static method of core's Drupal class, as of Drupal 11.4, that gets one fixed service from
+  # the container, and that service. cache() names its service by its argument and is left out.
+  shortcut_services:
+    accessManager: access_manager
+    classResolver: class_resolver
+    config: config.factory
+    configFactory: config.factory
+    csrfToken: csrf_token
+    currentUser: current_user
+    database: database
+    destination: redirect.destination
+    entityDefinitionUpdateManager: entity.definition_update_manager
+    entityTypeManager: entity_type.manager
+    flood: flood
+    formBuilder: form_builder
+    hasRequest: request_stack
+    httpClient: http_client
+    isConfigSyncing: config.installer
+    keyValue: keyvalue
+    keyValueExpirable: keyvalue.expirable
+    languageManager: language_manager
+    linkGenerator: link_generator
+    lock: lock
+    logger: logger.factory
+    menuTree: menu.link_tree
+    messenger: messenger
+    moduleHandler: module_handler
+    pathValidator: path.validator
+    queue: queue
+    request: request_stack
+    requestStack: request_stack
+    routeMatch: current_route_match
+    state: state
+    theme: theme.manager
+    time: datetime.time
+    token: token
+    transliteration: transliteration
+    translation: string_translation
+    typedDataManager: typed_data_manager
+    urlGenerator: url_generator
+  # Each entity class of Drupal 11.4 core by its short name, and its entity type id. Message, the
+  # contact module's class for contact_message, is left out: the Message module's class for the
+  # entity type message has the same short name.
+  entity_classes:
+    Action: action
+    BaseFieldOverride: base_field_override
+    Block: block
+    BlockContent: block_content
+    BlockContentType: block_content_type
+    Comment: comment
+    CommentType: comment_type
+    ConfigurableLanguage: configurable_language
+    ContactForm: contact_form
+    ContentLanguageSettings: language_content_settings
+    ContentModerationState: content_moderation_state
+    DateFormat: date_format
+    Editor: editor
+    EntityFormDisplay: entity_form_display
+    EntityFormMode: entity_form_mode
+    EntityViewDisplay: entity_view_display
+    EntityViewMode: entity_view_mode
+    FieldConfig: field_config
+    FieldStorageConfig: field_storage_config
+    File: file
+    FilterFormat: filter_format
+    ImageStyle: image_style
+    Media: media
+    MediaType: media_type
+    Menu: menu
+    MenuLinkContent: menu_link_content
+    Node: node
+    NodeType: node_type
+    PathAlias: path_alias
+    ResponsiveImageStyle: responsive_image_style
+    RestResourceConfig: rest_resource_config
+    Role: user_role
+    SearchPage: search_page
+    Shortcut: shortcut
+    ShortcutSet: shortcut_set
+    Term: taxonomy_term
+    User: user
+    View: view
+    Vocabulary: taxonomy_vocabulary
+    Workflow: workflow
+    Workspace: workspace
+
+# The core and Symfony classes and interfaces that the custom code builds on and the map never
+# reads. Each one an inherits or implements edge reaches becomes a declared node this pack draws,
+# with no location. A custom class that descends from a name with a type takes that type: those
+# roles have no attribute to read. A plugin base names no type, because its attribute or
+# annotation already gives the plugin. Contributed modules' bases belong to their own rutters.
+boundary:
+  core_classes:
+    type: php.class_like
+    ancestry: [inherits, implements]
+    names:
+      Drupal\Component\Plugin\Attribute\Plugin: ~
+      Drupal\Component\Plugin\Derivative\DeriverBase: ~
+      Drupal\Core\Block\BlockBase: ~
+      Drupal\Core\Config\Entity\ConfigEntityBase: ~
+      Drupal\Core\Config\Entity\ConfigEntityListBuilder: ~
+      Drupal\Core\Controller\ControllerBase: drupal.controller_class
+      Drupal\Core\Entity\ContentEntityBase: ~
+      Drupal\Core\Entity\EntityAccessControlHandler: ~
+      Drupal\Core\Entity\EntityDeleteForm: ~
+      Drupal\Core\Entity\EntityForm: ~
+      Drupal\Core\EventSubscriber\HttpExceptionSubscriberBase: ~
+      Drupal\Core\Form\ConfigFormBase: drupal.config_form_class
+      Drupal\Core\Form\ConfirmFormBase: ~
+      Drupal\Core\Form\FormBase: drupal.form_class
+      Drupal\Core\Mail\Plugin\Mail\PhpMail: ~
+      Drupal\Core\Plugin\DefaultPluginManager: ~
+      Drupal\Core\Plugin\PluginBase: ~
+      Drupal\Core\Queue\QueueWorkerBase: ~
+      Drupal\Core\Routing\RouteSubscriberBase: ~
+      Drupal\KernelTests\Components\ComponentKernelTestBase: ~
+      Drupal\KernelTests\KernelTestBase: ~
+      Drupal\Tests\BrowserTestBase: ~
+      Drupal\Tests\UnitTestCase: ~
+      Symfony\Component\Validator\Constraint: ~
+      Symfony\Component\Validator\ConstraintValidator: ~
+      Symfony\Contracts\EventDispatcher\Event: ~
+  core_interfaces:
+    type: php.interface
+    ancestry: [inherits, implements]
+    names:
+      Drupal\Component\Plugin\PluginInspectionInterface: ~
+      Drupal\Core\Ajax\CommandInterface: ~
+      Drupal\Core\Cache\CacheableDependencyInterface: ~
+      Drupal\Core\DependencyInjection\ContainerInjectionInterface: ~
+      Drupal\Core\DependencyInjection\ServiceModifierInterface: ~
+      Drupal\Core\Entity\EntityHandlerInterface: ~
+      Drupal\Core\Flood\FloodInterface: ~
+      Drupal\Core\Form\FormInterface: ~
+      Drupal\Core\Lock\LockBackendInterface: ~
+      Drupal\Core\Plugin\ContainerFactoryPluginInterface: ~
+      Drupal\Core\Plugin\Discovery\ContainerDeriverInterface: ~
+      Drupal\Core\Queue\QueueInterface: ~
+      Drupal\Core\Routing\Access\AccessInterface: ~
+      Symfony\Component\EventDispatcher\EventSubscriberInterface: drupal.event_subscriber_class

periplus/packs/drupal_basic@0.3.0/permission/permission.yaml

@@ -0,0 +1,7 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A permission, named by its key in a permissions file.
+
+node_types:
+- name: drupal.permission
+  id_namespace: drupal.permission

periplus/packs/drupal_basic@0.3.0/permission/permission_definition.yaml

@@ -0,0 +1,27 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A permission read from a permissions file, one per top-level key that has a title. One rule. The
+# key permission_callbacks is a list, not a permission, and has no title.
+
+rules:
+- rule: permission_from_permissions_file
+  reads: file
+  in:
+  - module_root
+  match:
+    file: '*.permissions'
+    filetype: yaml
+    each: '*'
+    where:
+    - has_key:
+        path: title
+  id:
+    from: key
+  emits:
+  - node:
+      type: drupal.permission
+  - attribute:
+      name: title
+      from:
+        key: title
+  confidence: declared

periplus/packs/drupal_basic@0.3.0/queue_worker/queue_worker.yaml

@@ -0,0 +1,9 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A queue worker plugin, named by its plugin id; plugin_class joins it to its class. It ends at the
+# same type and id namespace whichever way it is declared.
+
+node_types:
+- name: drupal.queue_worker_plugin
+  parent: drupal.plugin
+  id_namespace: drupal.plugin.queue_worker

periplus/packs/drupal_basic@0.3.0/queue_worker/queue_worker_annotation.yaml

@@ -0,0 +1,43 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A queue worker plugin declared by the QueueWorker docblock annotation on its class. Two rules
+# because a rule that emits an edge emits no node. An id that is not text in double quotes makes no
+# plugin and is listed under skipped in the map report.
+
+rules:
+- rule: queue_worker_from_annotation
+  reads: file
+  in:
+  - queue_worker_classes
+  match:
+    annotation: QueueWorker
+    filetype: php
+    where:
+    - applies_to: class_declaration
+  id:
+    from:
+      annotation_key: id
+    must_be: string_literal
+  emits:
+  - node:
+      type: drupal.queue_worker_plugin
+  confidence: declared
+- rule: queue_worker_from_annotation_edges
+  reads: file
+  in:
+  - queue_worker_classes
+  match:
+    annotation: QueueWorker
+    filetype: php
+    where:
+    - applies_to: class_declaration
+  id:
+    from:
+      annotation_key: id
+    must_be: string_literal
+  emits:
+  - edge:
+      kind: plugin_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared

periplus/packs/drupal_basic@0.3.0/queue_worker/queue_worker_attribute.yaml

@@ -0,0 +1,43 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A queue worker plugin declared by the QueueWorker attribute on its class. Two rules because a rule
+# that emits an edge emits no node. An id that is not a text literal makes no plugin and is listed
+# under skipped in the map report.
+
+rules:
+- rule: queue_worker_from_attribute
+  reads: file
+  in:
+  - queue_worker_classes
+  match:
+    attribute: Drupal\Core\Queue\Attribute\QueueWorker
+    filetype: php
+    where:
+    - applies_to: class_declaration
+  id:
+    from:
+      attribute_argument: id
+    must_be: string_literal
+  emits:
+  - node:
+      type: drupal.queue_worker_plugin
+  confidence: declared
+- rule: queue_worker_from_attribute_edges
+  reads: file
+  in:
+  - queue_worker_classes
+  match:
+    attribute: Drupal\Core\Queue\Attribute\QueueWorker
+    filetype: php
+    where:
+    - applies_to: class_declaration
+  id:
+    from:
+      attribute_argument: id
+    must_be: string_literal
+  emits:
+  - edge:
+      kind: plugin_class
+      from: this_node
+      to: enclosing_class
+  confidence: declared

periplus/packs/drupal_basic@0.3.0/rest_resource/rest_resource.yaml

@@ -0,0 +1,8 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A REST resource plugin, named by its plugin id; plugin_class joins it to its class.
+
+node_types:
+- name: drupal.rest_resource
+  parent: drupal.plugin
+  id_namespace: drupal.plugin.rest_resource