diff --git a/src/app.tsx b/src/app.tsx
index 33ce025..e4f9a7b 100644
--- a/src/app.tsx
+++ b/src/app.tsx
@@ -40,7 +40,7 @@ async function onAppSettingsChanged() {
     dayjs.updateLocale('en', {
         weekStart: 1,
     })
- }
+}
 
 async function init() {
     if (DEV) {
@@ -225,15 +225,15 @@ async function main() {
             showInsertUI(e.uuid)
         })
 
-        registerBlockContextCopyCommand('Copy as 🏛template', commandTemplateName)
-        registerPageContextCopyCommand('Copy as 🏛template', commandTemplateName)
+        registerBlockContextCopyCommand('Copy as 🏛template', false)
+        registerPageContextCopyCommand('Copy as 🏛template', false)
         handleTemplateCommand(commandTemplateName)
     }
 
     const commandTemplateViewName = 'template-view'
     {
-        registerBlockContextCopyCommand('Copy as 🏛view', commandTemplateViewName)
-        registerPageContextCopyCommand('Copy as 🏛view', commandTemplateViewName)
+        registerBlockContextCopyCommand('Copy as 🏛view', true)
+        registerPageContextCopyCommand('Copy as 🏛view', true)
         handleTemplateViewCommand(commandTemplateViewName)
     }
 
@@ -241,7 +241,10 @@ async function main() {
     {
         const commandLabel = 'Insert inline 🏛view'
         const code = 'c.page.name'
-        const commandGuide = RendererMacro.command(commandViewName).arg(`"${code}"`).toString()
+        const commandGuide = RendererMacro
+            .command(commandViewName)
+            .arg(`"${code}"`, {raw: true})
+            .toString()
 
         logseq.App.registerCommandPalette({
             key: 'insert-inline-view',
@@ -270,10 +273,10 @@ async function main() {
     await postInit()
 }
 
-function registerBlockContextCopyCommand(label: string, commandName: string) {
+function registerBlockContextCopyCommand(label: string, isView: boolean) {
     logseq.Editor.registerBlockContextMenuItem(
         label, async (e) => {
-            const macro = await templateMacroStringForBlock(e.uuid)
+            const macro = await templateMacroStringForBlock(e.uuid, isView)
             if (!macro) {
                 console.debug(p`Assertion error: block should exists`, e.uuid)
                 return
@@ -285,11 +288,10 @@ function registerBlockContextCopyCommand(label: string, commandName: string) {
             await logseq.UI.showMsg('Copied to clipboard', 'success', {timeout: 5000})
     })
 }
-
-function registerPageContextCopyCommand(label: string, commandName: string) {
+function registerPageContextCopyCommand(label: string, isView: boolean) {
     logseq.App.registerPageMenuItem(
         label, async ({ page: pageName }) => {
-            const command = await templateMacroStringForPage(pageName)
+            const command = await templateMacroStringForPage(pageName, isView)
             if (!command) {
                 console.debug(p`Assertion error: page should exists`, pageName)
                 return
@@ -310,7 +312,7 @@ async function handleRequiredRef(ref: string, refUserName: string) {
     }
 
     return parseReference(ref)!
- }
+}
 async function handleLogicErrors(func: Function) {
     try {
         await func()
@@ -324,7 +326,7 @@ async function handleLogicErrors(func: Function) {
         else
             console.error(p`${(error as Error).stack}`)
     }
- }
+}
 
 function handleTemplateCommand(commandName: string) {
     let unload = logseq.App.onMacroRendererSlotted(async ({ slot, payload }) => {
@@ -350,7 +352,7 @@ function handleTemplateCommand(commandName: string) {
         })
     })
     logseq.beforeunload(unload as unknown as () => Promise<void>)
- }
+}
 function handleTemplateViewCommand(commandName: string) {
     logseq.provideModel({
         async editBlock(e: any) {
@@ -423,7 +425,7 @@ function handleTemplateViewCommand(commandName: string) {
         })
     })
     logseq.beforeunload(unload as unknown as () => Promise<void>)
- }
+}
 function handleViewCommand(commandName: string) {
     const unload = logseq.App.onMacroRendererSlotted(async ({ slot, payload }) => {
         const uuid = payload.uuid
@@ -446,11 +448,11 @@ function handleViewCommand(commandName: string) {
 
         console.debug(p`Rendering view`, {slot, uuid, viewBody, args})
         await handleLogicErrors(async () => {
-            await renderView(slot, uuid, viewBody, raw, args)
+            await renderView(slot, uuid, viewBody, args)
         })
     })
     logseq.beforeunload(unload as unknown as () => Promise<void>)
- }
+}
 
 
 export const App = (logseq: any) => {
diff --git a/src/context.ts b/src/context.ts
index e74aa3c..aef3041 100644
--- a/src/context.ts
+++ b/src/context.ts
@@ -54,17 +54,26 @@ dayjs.extend(updateLocale)
 dayjs.extend(logseqPlugin)
 
 
-export interface ILogseqContext {
+export interface ILogseqCurrentContext {
+    mode: 'template' | 'view'
+    currentPage: PageContext
+    currentBlock: BlockContext
+}
+
+export interface ILogseqCallContext {
     identity: Context | {
         slot: string,
         key: string,
     }
     config: ConfigContext
+    page: PageContext | null
+    block: BlockContext | null
+    args: ArgsContext
+}
+
+export interface ILogseqContext extends ILogseqCallContext, ILogseqCurrentContext {
     page: PageContext
-    currentPage: PageContext
     block: BlockContext
-    currentBlock: BlockContext
-    args: ArgsContext
 
     tags?: Context
     self?: BlockContext
diff --git a/src/extensions/customized_eta.ts b/src/extensions/customized_eta.ts
index 4548a9d..76d9b1d 100644
--- a/src/extensions/customized_eta.ts
+++ b/src/extensions/customized_eta.ts
@@ -194,7 +194,7 @@ function compileBody(buff) {
     // @ts-expect-error
     const config = this.config
 
-    let returnStr = ''
+    let returnStr = 'include = undefined; includeAsync = undefined; layout = undefined;\n'
     for (const currentBlock of buff) {
         if (typeof currentBlock === 'string') {
             const str = currentBlock
diff --git a/src/logic.ts b/src/logic.ts
index 5639dbd..d6df43b 100644
--- a/src/logic.ts
+++ b/src/logic.ts
@@ -5,7 +5,7 @@ import { LogseqMarkup } from './extensions/mldoc_ast'
 import { InlineTemplate, ITemplate, Template } from './template'
 import {
     ILogseqContext, Context, PageContext, BlockContext,
-    ArgsContext, ConfigContext,
+    ArgsContext, ConfigContext, ILogseqCurrentContext, ILogseqCallContext,
 } from './context'
 import {
     p, IBlockNode, lockOn, sleep, LogseqReference, getPage, getBlock,
@@ -17,15 +17,10 @@ import {
 import { RenderError, StateError, StateMessage } from './errors'
 
 
-/**
- * @raises StateError: Arg `:page` doesn't exist or improperly specified
- */
 async function getCurrentContext(
-    slot: string,
-    template: ITemplate,
     blockUUID: string,
-    argsContext: ArgsContext,
-): Promise<ILogseqContext | null> {
+    mode: ILogseqCurrentContext['mode'],
+): Promise<ILogseqCurrentContext | null> {
     if (!blockUUID) {
         // Where is uuid? It definitely should be here, but this is a bug:
         //   https://github.com/logseq/logseq/issues/8904
@@ -33,6 +28,32 @@ async function getCurrentContext(
         return null
     }
 
+    const currentBlock = await logseq.Editor.getBlock(blockUUID)
+    if (!currentBlock) {
+        console.debug(p`logseq issue → rendering non-existed block / slot`)
+        return null
+    }
+
+    const currentPage = await logseq.Editor.getPage(currentBlock.page.id) as PageEntity
+    const currentPageContext = PageContext.createFromEntity(currentPage)
+    const currentBlockContext = BlockContext.createFromEntity(currentBlock, { page: currentPageContext })
+
+    return {
+        mode,
+        currentPage: currentPageContext,
+        currentBlock: currentBlockContext,
+    }
+}
+
+/**
+ * @raises StateError: Arg `:page` doesn't exist or improperly specified
+ * @raises StateError: Arg `:block` doesn't exist or improperly specified
+ */
+async function getCallContext(
+    slot: string,
+    template: ITemplate,
+    argsContext: ArgsContext,
+): Promise<ILogseqCallContext> {
     // fulfill args with template arg-props
     const argsProps = template.getArgProperties()
     for (const [ key, value ] of Object.entries(argsProps))
@@ -80,35 +101,41 @@ async function getCurrentContext(
         contextBlock = blockExists
     }
 
-    const currentBlock = await logseq.Editor.getBlock(blockUUID)
-    if (!currentBlock) {
-        console.debug(p`logseq issue → rendering non-existed block / slot`)
-        return null
-    }
-
-    const currentPage = await logseq.Editor.getPage(currentBlock.page.id) as PageEntity
-    const currentPageContext = PageContext.createFromEntity(currentPage)
-    const currentBlockContext = BlockContext.createFromEntity(currentBlock, { page: currentPageContext })
-
     argsContext._hideUndefinedMode = true
     return {
         identity: new Context({ slot, key: slot.split('__', 2)[1].trim() }),
         config: await ConfigContext.get(),
 
-        page: contextPage ? PageContext.createFromEntity(contextPage) : currentPageContext,
-        currentPage: currentPageContext,
+        page: contextPage ? PageContext.createFromEntity(contextPage) : null,
+        block: contextBlock ? BlockContext.createFromEntity(contextBlock) : null,
+        args: argsContext,
+    }
+}
 
-        block: contextBlock ? BlockContext.createFromEntity(contextBlock) : currentBlockContext,
-        currentBlock: currentBlockContext,
+async function getContext(
+    callContext: ILogseqCallContext,
+    currentContext: ILogseqCurrentContext,
+): Promise<ILogseqContext> {
+    return {
+        mode: currentContext.mode,
+        identity: callContext.identity,
+        config: callContext.config,
 
-        args: argsContext,
+        page: callContext.page || currentContext.currentPage,
+        currentPage: currentContext.currentPage,
+
+        block: callContext.block || currentContext.currentBlock,
+        currentBlock: currentContext.currentBlock,
+
+        args: callContext.args,
     }
- }
+}
+
 
 /**
  * @raises StateError: template doesn't exist
  */
-async function getTemplateBlock(
+export async function getTemplateBlock(
     templateRef: LogseqReference
 ): Promise<[BlockEntity, string | undefined, LogseqReferenceAccessType]> {
     let templateBlock: BlockEntity | null
@@ -144,7 +171,7 @@ async function getTemplateBlock(
     return [ templateBlock, name, accessedVia ]
  }
 
-async function getTemplate(ref: LogseqReference): Promise<Template> {
+export async function getTemplate(ref: LogseqReference): Promise<Template> {
     const [ templateBlock, name, accessedVia ] = await getTemplateBlock(ref)
 
     let includingParent: boolean | undefined
@@ -270,10 +297,15 @@ async (
     if (handled)
         return
 
-    const context = await getCurrentContext(slot, template, uuid, argsContext)
-    if (!context)
+    const currentContext = await getCurrentContext(uuid, 'template')
+    if (!currentContext)
         return
 
+    const context = await getContext(
+        await getCallContext(slot, template, argsContext),
+        currentContext,
+    )
+
     let rendered: IBlockNode
     try {
         rendered = await template.render(context)
@@ -335,20 +367,18 @@ async (
 })
 
 /**
- * @raises StateError: template doesn't exist
- * @raises StateMessage: template doesn't have any content (empty)
  * @raises RenderError: template rendering error
  */
-async function _renderTemplateView(
+export async function compileTemplateView(
     slot: string,
-    blockUUID: string,
     template: ITemplate,
-    rawCode: RendererMacro,
     argsContext: ArgsContext,
-) {
-    const context = await getCurrentContext(slot, template, blockUUID, argsContext)
-    if (!context)
-        return
+    currentContext: ILogseqCurrentContext,
+): Promise<string> {
+    const context = await getContext(
+        await getCallContext(slot, template, argsContext),
+        currentContext,
+    )
 
     let rendered: IBlockNode
     try {
@@ -366,7 +396,7 @@ async function _renderTemplateView(
         )
     }
 
-    const compiled = await walkBlockTree(rendered, async (b, lvl) => {
+    let compiled = await walkBlockTree(rendered, async (b, lvl) => {
         const content = (b.content || '').toString()
         if (!content.trim())
             return ''
@@ -375,6 +405,9 @@ async function _renderTemplateView(
     })
     console.debug(p`Markup compiled:`, {data: compiled})
 
+    if (compiled.content === '' && compiled.children.length === 1)
+        compiled = compiled.children[0]
+
     const htmlFold = (node: IBlockNode, level = 0): string => {
         const children = () => node.children.map(
             (n) => htmlFold(n as IBlockNode, level + 1)
@@ -413,6 +446,20 @@ async function _renderTemplateView(
     const view = htmlFold(compiled)
     console.debug(p`View folded:`, {view})
 
+    return view
+}
+
+async function _renderTemplateView(
+    slot: string,
+    blockUUID: string,
+    template: ITemplate,
+    argsContext: ArgsContext,
+) {
+    const currentContext = await getCurrentContext(blockUUID, 'view')
+    if (!currentContext)
+        return
+
+    const view = await compileTemplateView(slot, template, argsContext, currentContext)
     provideHTML(blockUUID, view, slot)
 }
 
@@ -430,20 +477,19 @@ export async function renderTemplateView(
     if (handled)
         return
 
-    await _renderTemplateView(slot, blockUUID, template, rawCode, argsContext)
- }
+    await _renderTemplateView(slot, blockUUID, template, argsContext)
+}
 
 export async function renderView(
     slot: string,
     blockUUID: string,
     viewBody: string,
-    rawCode: RendererMacro,
     args: string[] = [],
 ) {
     const template = getView(viewBody)
     const argsContext = ArgsContext.create(template.name, args)
-    await _renderTemplateView(slot, blockUUID, template, rawCode, argsContext)
- }
+    await _renderTemplateView(slot, blockUUID, template, argsContext)
+}
 
 export async function templateMacroStringForBlock(uuid: string, isView: boolean = false): Promise<string> {
     const block = await logseq.Editor.getBlock(uuid)
diff --git a/src/tags.ts b/src/tags.ts
index 519151a..4c15a28 100644
--- a/src/tags.ts
+++ b/src/tags.ts
@@ -5,11 +5,16 @@ import * as Sherlock from 'sherlockjs'
 
 import { LogseqDayjsState } from './extensions/dayjs_logseq_plugin'
 import { LogseqMarkup, MLDOC_Node, resolveAssetsLink } from './extensions/mldoc_ast'
-import { BlockContext, Context, dayjs, Dayjs, ILogseqContext, PageContext }  from './context'
+import { ArgsContext, BlockContext, Context, dayjs, Dayjs, ILogseqContext, ILogseqCurrentContext, PageContext }  from './context'
 import {
+    cleanMacroArg,
+    escapeMacroArg,
     getBlock, getPage, IBlockNode, isEmptyString, isObject, isUUID,
-    LogseqReference, p, parseReference, unquote, walkBlockTree
+    LogseqReference, p, parseReference, RendererMacro, splitMacroArgs, unquote, walkBlockTree
 } from './utils'
+import { compileTemplateView, getTemplate, getTemplateBlock, templateMacroStringForBlock } from './logic'
+import { StateError } from './errors'
+import { ITemplate, Template } from './template'
 
 
 const isoDateFromat = 'YYYY-MM-DD'
@@ -155,6 +160,63 @@ function embed(item: string | BlockContext | PageContext | Dayjs): string {
     return `{{embed ${r}}}`
 }
 
+async function _template(ref: LogseqReference, args: string[]): Promise<string> {
+    let block: BlockEntity
+    try {
+        [block, ] = await getTemplateBlock(ref)
+    } catch (error) {  // StateError
+        return ''
+    }
+
+    let command = RendererMacro.command('template').arg(ref.value as string)
+
+    if (args.length !== 0)
+        command = command.args(args)
+    else {
+        const templateUsage = Template.getUsageString(block, {cleanMarkers: true})
+        if (templateUsage)
+            command = command.arg(templateUsage, {raw: true})
+    }
+
+    return command.toString()
+}
+async function _view(context: ILogseqContext, ref: LogseqReference, args: string[]): Promise<string> {
+    let template: Template
+    try {
+        template = await getTemplate(ref)
+    } catch (error) {  // StateMessage
+        return ''
+    }
+
+    if (args.length === 0) {
+        const templateUsage = Template.getUsageString(template.block, {cleanMarkers: true})
+        if (templateUsage)
+            args = splitMacroArgs(templateUsage)
+    }
+    const argsContext = ArgsContext.create(template.name, args)
+
+    return compileTemplateView(
+        // @ts-expect-error
+        context.identity.slot,
+        template,
+        argsContext,
+        context as ILogseqCurrentContext,
+    )
+}
+async function include(context: ILogseqContext, name: string, ...args: string[]) {
+    const ref = parseReference(name ?? '')
+    if (!ref)
+        return ''
+
+    args = args.map((arg) => arg.toString())
+
+    if (context.mode === 'template')
+        return _template(ref, args)
+    else if (context.mode === 'view')
+        return _view(context, ref, args)
+    return ''
+}
+
 function empty(obj: any, fallback: any = ''): any {
     if (obj === null)
         return obj
@@ -475,6 +537,7 @@ export function getTemplateTagsContext(context: ILogseqContext) {
                 page: function (entity) { return PageContext.createFromEntity(entity) },
                 block: function (entity) { return BlockContext.createFromEntity(entity) },
             }),
+            include: bindContext(include, context),
         }),
         date: Object.assign(datesContext.date, {
             nlp: bindContext(date_nlp, context),
diff --git a/src/utils/logseq.ts b/src/utils/logseq.ts
index 0986178..4966f8a 100644
--- a/src/utils/logseq.ts
+++ b/src/utils/logseq.ts
@@ -330,7 +330,23 @@ export async function getPageFirstBlock(
     return await logseq.Editor.getBlock(block.id, {includeChildren})
 }
 
+export function escapeMacroArg(
+    arg: string, opts = {
+    quote: true,
+    escape: true,
+}): string {
+    if (opts.quote && arg.includes(',') && !(arg.startsWith('"') && arg.endsWith('"')))
+        arg = `"${arg}"`
 
+    // To deal with XSS: escape dangerous (for datascript raw queries) chars
+    const escapeMap = {
+        '"': '\\"',
+    }
+
+    const chars = Object.keys(escapeMap).join('')
+    arg = arg.replaceAll(new RegExp(`[${chars}]`, 'g'), (ch) => escapeMap[ch])
+    return arg
+}
 export function cleanMacroArg(
     arg: string | null | undefined, opts = {
     escape: true,
@@ -348,16 +364,12 @@ export function cleanMacroArg(
     if (!opts.escape)
         return arg
 
-    // To deal with XSS: escape dangerous (for datascript raw queries) chars
-    const escapeMap = {
-        '"': '\\"',
-    }
-
-    const chars = Object.keys(escapeMap).join('')
-    arg = arg.replaceAll(new RegExp(`[${chars}]`, 'g'), (ch) => escapeMap[ch])
-    return arg
+    return escapeMacroArg(arg, {quote: false, escape: true})
+}
+export function splitMacroArgs(args: string) {
+    // source: https://stackoverflow.com/a/11457952
+    return Array.from(args.match(/(".*?"|[^",\s]+)(?=\s*,|\s*$)/g) ?? [])
 }
-
 
 type LogseqProperty = { name: string, text: string, refs: string[] }
 
@@ -529,8 +541,8 @@ export class Macro {
         if (!value)
             return this
 
-        if (!opts.raw && value.includes(','))
-            value = '"' + value + '"'
+        if (!opts.raw)
+            value = escapeMacroArg(value, {quote: true, escape: false})
 
         const obj = this.clone()
         obj.arguments.push(value)
@@ -543,9 +555,7 @@ export class Macro {
 
         if (!opts.raw)
             values = values.map((value) => {
-                if (value.includes(','))
-                    value = '"' + value + '"'
-                return value
+                return escapeMacroArg(value, {quote: true, escape: false})
             })
 
         const obj = this.clone()