# runtime/entrypoints/template.entrypoint.ts

> 43 lines of code and 8 definitions.

Tree: Build tree
Language: typescript
Layer: runtime
Canonical: https://banes-lab.com/anatomy/build#file-build-runtime-entrypoints-template-entrypoint-ts
Source text: https://banes-lab.com/source/build/runtime/entrypoints/template.entrypoint.ts.txt

Listed in [runtime/entrypoints](https://banes-lab.com/api/source/build/runtime/entrypoints.md), after [runtime/entrypoints/seed.entrypoint.ts](https://banes-lab.com/source/build/runtime/entrypoints/seed.entrypoint.ts.md) and before [runtime/entrypoints/tone.entrypoint.ts](https://banes-lab.com/source/build/runtime/entrypoints/tone.entrypoint.ts.md).

## Definitions

- `hostTemplates` (lexical_declaration, line 21)
- `coordination` (lexical_declaration, line 22)
- `filesUnder` (lexical_declaration, line 24)
- `templates` (lexical_declaration, line 30)
- `stringsModules` (lexical_declaration, line 35)
- `files` (lexical_declaration, line 39)
- `members` (lexical_declaration, line 45)
- `findings` (lexical_declaration, line 47)

## Records this file checks

- [Traceability](https://banes-lab.com/records/architecture/traceability.md)

## Source

```typescript
import { CLEAN_TEMPLATES, NO_TEMPLATES, unresolvedTemplateRef } from "#configuration/strings/template.strings";
import { ROOT, absolutePath } from "@ssot/paths";
import { conclude, refuse } from "#core/reporters/derivation.reporter";
import { createGovlabContext, unresolvedTemplateRefsOf } from "@govlab/context";
import { existsSync, readFileSync, readdirSync } from "node:fs";
import { join, relative, sep } from "node:path";
import type { Finding } from "#types/derivation.types";
import { STRINGS_SUFFIX } from "#configuration/constants/tone.constants";
import { TEMPLATE_COMMAND } from "#configuration/constants/contract.constants";
import { TEMPLATE_SUFFIX } from "#configuration/constants/template.constants";
import { TEMPLATE_SUMMARY } from "#configuration/strings/contract.strings";
import { defineCheck } from "@govlab/context/check";
import { packageFiles } from "#core/loaders/coordination.loader";
import { resolveArgv } from "@govlab/argv";
import { stringsFolders } from "#core/loaders/strings.loader";

defineCheck({ detects: [], enforces: ["architecture:traceability"] });

resolveArgv({ command: TEMPLATE_COMMAND, flags: [], summary: TEMPLATE_SUMMARY });

const hostTemplates = absolutePath("docArch.templates");
const coordination = absolutePath("app.coordination");

const filesUnder = function filesUnder(folder: string): string[] {
    return existsSync(folder)
        ? readdirSync(folder, { encoding: "utf8", recursive: true }).map((name) => join(folder, name))
        : [];
};

const templates = [
    ...filesUnder(hostTemplates),
    ...(existsSync(coordination) ? packageFiles(coordination) : []),
].filter((file) => file.endsWith(TEMPLATE_SUFFIX));

const stringsModules = stringsFolders()
    .flatMap((folder) => filesUnder(folder))
    .filter((file) => file.endsWith(STRINGS_SUFFIX));

const files = [...templates, ...stringsModules];

if (files.length === 0) {
    refuse(`${NO_TEMPLATES}${hostTemplates}`);
}

const members = createGovlabContext().reason.kindMembers();

const findings: Finding[] = files.flatMap((file) =>
    unresolvedTemplateRefsOf(readFileSync(file, "utf8"), members).map((ref) => ({
        file: relative(ROOT, file).split(sep).join("/"),
        message: unresolvedTemplateRef(ref.line, ref.kind, ref.id),
    })),
);

conclude(TEMPLATE_COMMAND, findings, CLEAN_TEMPLATES);
```